﻿using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text;
using Vanara.Extensions;
using Vanara.Extensions.Reflection;
using Vanara.InteropServices;
using static Vanara.PInvoke.Kernel32;

namespace Vanara.PInvoke
{
	/// <summary>Platform invokable enumerated types, constants and functions from ntdll.h</summary>
	public static partial class NtDll
	{
		/// <summary>
		/// <para>The <c>KEY_INFORMATION_CLASS</c> enumeration type represents the type of information to supply about a registry key.</para>
		/// </summary>
		/// <remarks>
		/// <para>
		/// Use the <c>KEY_INFORMATION_CLASS</c> values to specify the type of data to be supplied by the ZwEnumerateKey and ZwQueryKey routines.
		/// </para>
		/// </remarks>
		// https://docs.microsoft.com/en-us/windows-hardware/drivers/ddi/content/wdm/ne-wdm-_key_information_class typedef enum
		// _KEY_INFORMATION_CLASS { KeyBasicInformation , KeyNodeInformation , KeyFullInformation , KeyNameInformation ,
		// KeyCachedInformation , KeyFlagsInformation , KeyVirtualizationInformation , KeyHandleTagsInformation , KeyTrustInformation ,
		// KeyLayerInformation , MaxKeyInfoClass } KEY_INFORMATION_CLASS;
		[PInvokeData("wdm.h", MSDNShortId = "cb531a0e-c934-4f3e-9b92-07eb3ab75673")]
		public enum KEY_INFORMATION_CLASS : uint
		{
			/// <summary>A KEY_BASIC_INFORMATION structure is supplied.</summary>
			[CorrespondingType(typeof(KEY_BASIC_INFORMATION))]
			KeyBasicInformation,

			/// <summary>A KEY_NODE_INFORMATION structure is supplied.</summary>
			[CorrespondingType(typeof(KEY_NODE_INFORMATION))]
			KeyNodeInformation,

			/// <summary>A KEY_FULL_INFORMATION structure is supplied.</summary>
			[CorrespondingType(typeof(KEY_FULL_INFORMATION))]
			KeyFullInformation,

			/// <summary>A KEY_NAME_INFORMATION structure is supplied.</summary>
			[CorrespondingType(typeof(KEY_NAME_INFORMATION))]
			KeyNameInformation,

			/// <summary>A KEY_CACHED_INFORMATION structure is supplied.</summary>
			KeyCachedInformation,

			/// <summary>Reserved for system use.</summary>
			KeyFlagsInformation,

			/// <summary>A KEY_VIRTUALIZATION_INFORMATION structure is supplied.</summary>
			KeyVirtualizationInformation,

			/// <summary>Reserved for system use.</summary>
			KeyHandleTagsInformation,

			/// <summary/>
			KeyTrustInformation,

			/// <summary/>
			KeyLayerInformation,

			/// <summary>The maximum value in this enumeration type.</summary>
			MaxKeyInfoClass,
		}

		/// <summary>
		/// <para>The <c>DbgBreakPoint</c> routine breaks into the kernel debugger.</para>
		/// </summary>
		/// <returns>
		/// <para>None</para>
		/// </returns>
		/// <remarks>
		/// <para>The <c>DbgBreakPoint</c> routine is the kernel-mode equivalent of <c>DebugBreak</c>.</para>
		/// <para>
		/// This routine raises an exception that is handled by the kernel debugger if one is installed; otherwise, it is handled by the
		/// debug system. If a debugger is not connected to the system, the exception can be handled in the standard way.
		/// </para>
		/// <para>
		/// In kernel mode, a break exception that is not handled will cause a bug check. You can, however, connect a kernel-mode debugger
		/// to a target computer that has stopped responding and has kernel debugging enabled. For more information, see Windows Debugging.
		/// </para>
		/// </remarks>
		// https://docs.microsoft.com/en-us/windows-hardware/drivers/ddi/content/wdm/nf-wdm-dbgbreakpoint __analysis_noreturn VOID
		// DbgBreakPoint( );
		[DllImport(Lib.NtDll, SetLastError = false, ExactSpelling = true)]
		[PInvokeData("wdm.h", MSDNShortId = "deeac910-2cc3-4a54-bf3b-aeb56d0004dc")]
		public static extern void DbgBreakPoint();

		/// <summary>
		/// <para>The <c>DbgPrint</c> routine sends a message to the kernel debugger. </para>
		/// <para>
		/// In Windows Vista and later versions of Windows, <c>DbgPrint</c> sends a message only when the conditions that you specify
		/// apply (see the <a href="#remarks">Remarks</a> section for information).
		/// </para>
		/// </summary>
		/// <param name="Format">
		/// <para>
		/// Specifies a pointer to the format string to print. The Format string supports most of the printf-style format specification fields.
		/// However, the Unicode format codes (%C, %S, %lc, %ls, %wc, %ws, and %wZ) can only be used with IRQL = PASSIVE_LEVEL.
		/// The <c>DbgPrint</c> routine does not support any of the floating point types (%f, %e, %E, %g, %G, %a, or %A).
		/// </para>
		/// </param>
		/// <param name="arguments">
		/// <para>Specifies arguments for the format string, as in <c>printf</c>.</para>
		/// </param>
		/// <returns>
		/// <para>If successful, <c>DbgPrint</c> returns the NTSTATUS code STATUS_SUCCESS; otherwise it returns the appropriate error code.</para>
		/// </returns>
		/// <remarks>
		/// <para>
		/// <c>DbgPrint</c> and <c>DbgPrintEx</c> can be called at IRQL&lt;=DIRQL. However, Unicode format codes (%wc and %ws) can be used only
		/// at IRQL=PASSIVE_LEVEL. Also, because the debugger uses interprocess interrupts (IPIs) to communicate with other processors,
		/// calling <c>DbgPrint</c> at IRQL&gt;DIRQL can cause deadlocks.
		/// </para>
		/// <para> Only kernel-mode drivers can call the <c>DbgPrint</c> routine. </para>
		/// <para>
		/// In Microsoft Windows Server 2003 and earlier versions of Windows, the <c>DbgPrint</c> routine sends a message to the kernel debugger.
		/// In Windows Vista and later versions of Windows, <c>DbgPrint</c> sends a message only if certain conditions apply.
		/// Specifically, it behaves like the DbgPrintEx routine with the DEFAULT component and a message importance level of DPFLTR_INFO_LEVEL.
		/// <code>
		/// DbgPrint ( Format, arguments ),
		/// DbgPrintEx ( DPFLTR_DEFAULT_ID, DPFLTR_INFO_LEVEL, Format, arguments )
		/// </code>
		/// </para>
		/// <para> For more information about message filtering, components, and message importance level, see Reading and Filtering Debugging Messages. </para>
		/// <para>
		/// Regardless of which version of Windows you are using, it is recommended that you use <c>DbgPrintEx</c> instead of <c>DbgPrint</c>,
		/// since this allows you to control the conditions under which the message is sent.
		/// </para>
		/// <para>
		/// Unless it is absolutely necessary, you should not obtain a string from user input or another process and pass it to <c>DbgPrint</c>.
		/// If you do use a string that you did not create, you must verify that this is a valid format string, and that the format codes
		/// match the argument list in type and quantity. The best coding practice is for all Format strings to be static and defined at compile time.
		/// </para>
		/// <para>
		/// There is no upper limit to the size of the Format string or the number of arguments. However, any single call to <c>DbgPrint</c>
		/// will only transmit 512 bytes of information. There is also a limit to the size of the <c>DbgPrint</c> buffer.
		/// See DbgPrint Buffer and the Debugger for details.
		/// </para>
		/// </remarks>
		// https://docs.microsoft.com/en-us/windows-hardware/drivers/ddi/wdm/nf-wdm-dbgprint ULONG DbgPrint([in] PCSTR Format,...);
		[DllImport(Lib.NtDll, SetLastError = false, ExactSpelling = true)]
		[PInvokeData("wdm.h", MSDNShortId = "NF:wdm.DbgPrint")]
		public static extern NTStatus DbgPrint([MarshalAs(UnmanagedType.LPStr)] string Format, [In] IntPtr arguments);

		/// <summary>
		/// <para>The <c>DbgPrint</c> routine sends a message to the kernel debugger.</para>
		/// <para>
		/// In Windows Vista and later versions of Windows, <c>DbgPrint</c> sends a message only when the conditions that you specify apply
		/// (see the Remarks section for information).
		/// </para>
		/// </summary>
		/// <param name="Format">
		/// Specifies a pointer to the format string to print. The <c>Format</c> string supports most of the <c>printf</c>-style format
		/// specification fields. However, the Unicode format codes ( <c>%C</c>, <c>%S</c>, <c>%lc</c>, <c>%ls</c>, <c>%wc</c>, <c>%ws</c>,
		/// and <c>%wZ</c>) can only be used with IRQL = PASSIVE_LEVEL. The <c>DbgPrint</c> routine does not support any of the floating
		/// point types ( <c>%f</c>, <c>%e</c>, <c>%E</c>, <c>%g</c>, <c>%G</c>, <c>%a</c>, or <c>%A</c>).
		/// </param>
		/// <param name="args">Specifies arguments for the format string, as in <c>printf</c>.</param>
		/// <returns>
		/// If successful, <c>DbgPrint</c> returns the NTSTATUS code STATUS_SUCCESS; otherwise it returns the appropriate error code.
		/// </returns>
		/// <remarks>
		/// <para>
		/// <c>DbgPrint</c> and <c>DbgPrintEx</c> can be called at IRQL&lt;=DIRQL. However, Unicode format codes (%wc and %ws) can be used
		/// only at IRQL=PASSIVE_LEVEL. Also, because the debugger uses interprocess interrupts (IPIs) to communicate with other processors,
		/// calling <c>DbgPrint</c> at IRQL&gt;DIRQL can cause deadlocks.
		/// </para>
		/// <para>Only kernel-mode drivers can call the <c>DbgPrint</c> routine.</para>
		/// <para>
		/// In Microsoft Windows Server 2003 and earlier versions of Windows, the <c>DbgPrint</c> routine sends a message to the kernel
		/// debugger. In Windows Vista and later versions of Windows, <c>DbgPrint</c> sends a message only if certain conditions apply.
		/// Specifically, it behaves like the DbgPrintEx routine with the DEFAULT component and a message importance level of
		/// DPFLTR_INFO_LEVEL. In other words, the following two function calls are identical:
		/// </para>
		/// <para>
		/// <code>DbgPrint ( Format, arguments ) DbgPrintEx ( DPFLTR_DEFAULT_ID, DPFLTR_INFO_LEVEL, Format, arguments )</code>
		/// </para>
		/// <para>
		/// For more information about message filtering, components, and message importance level, see Reading and Filtering Debugging Messages.
		/// </para>
		/// <para>
		/// <c>Note</c> Regardless of which version of Windows you are using, it is recommended that you use <c>DbgPrintEx</c> instead of
		/// <c>DbgPrint</c>, since this allows you to control the conditions under which the message is sent.
		/// </para>
		/// <para>
		/// Unless it is absolutely necessary, you should not obtain a string from user input or another process and pass it to
		/// <c>DbgPrint</c>. If you do use a string that you did not create, you must verify that this is a valid format string, and that the
		/// format codes match the argument list in type and quantity. The best coding practice is for all <c>Format</c> strings to be static
		/// and defined at compile time.
		/// </para>
		/// <para>
		/// There is no upper limit to the size of the <c>Format</c> string or the number of arguments. However, any single call to
		/// <c>DbgPrint</c> will only transmit 512 bytes of information. There is also a limit to the size of the DbgPrint buffer. See
		/// DbgPrint Buffer and the Debugger for details.
		/// </para>
		/// </remarks>
		[PInvokeData("wdm.h", MSDNShortId = "NF:wdm.DbgPrintEx")]
		public static NTStatus DbgPrint(string Format, params object[] args)
		{
			using var pargs = new SafeHGlobalHandle(InteropExtensions.MarshalObjectsToPtr(args, Marshal.AllocHGlobal, out var sz, true), sz, true);
			return DbgPrint(Format, pargs);
		}

		/// <summary>The <c>DbgPrintEx</c> routine sends a string to the kernel debugger if the conditions you specify are met.</summary>
		/// <param name="ComponentId">
		/// <para>
		/// Specifies the component calling this routine. This must be one of the component name filter IDs defined in the Dpfilter.h header
		/// file. To avoid mixing your driver's output with the output of Windows components, you should use only the following values for <c>ComponentId</c>:
		/// </para>
		/// <list type="bullet">
		/// <item>
		/// <term>DPFLTR_IHVVIDEO_ID</term>
		/// </item>
		/// <item>
		/// <term>DPFLTR_IHVAUDIO_ID</term>
		/// </item>
		/// <item>
		/// <term>DPFLTR_IHVNETWORK_ID</term>
		/// </item>
		/// <item>
		/// <term>DPFLTR_IHVSTREAMING_ID</term>
		/// </item>
		/// <item>
		/// <term>DPFLTR_IHVBUS_ID</term>
		/// </item>
		/// <item>
		/// <term>DPFLTR_IHVDRIVER_ID</term>
		/// </item>
		/// </list>
		/// </param>
		/// <param name="Level">
		/// Specifies the severity of the message being sent. This can be any 32-bit integer. Values between 0 and 31 (inclusive) are treated
		/// differently than values between 32 and 0xFFFFFFFF. For details, see Reading and Filtering Debugging Messages.
		/// </param>
		/// <param name="Format">
		/// Specifies a pointer to the format string to print. The <c>Format</c> string supports most of the <c>printf</c>-style format
		/// specification fields. However, the Unicode format codes ( <c>%C</c>, <c>%S</c>, <c>%lc</c>, <c>%ls</c>, <c>%wc</c>, <c>%ws</c>,
		/// and <c>%wZ</c>) can only be used with IRQL = PASSIVE_LEVEL. The <c>DbgPrintEx</c> routine does not support any of the floating
		/// point types ( <c>%f</c>, <c>%e</c>, <c>%E</c>, <c>%g</c>, <c>%G</c>, <c>%a</c>, or <c>%A</c>).
		/// </param>
		/// <param name="arguments">Specifies arguments for the format string, as in <c>printf</c>.</param>
		/// <returns>
		/// If successful, <c>DbgPrintEx</c> returns the NTSTATUS code STATUS_SUCCESS; otherwise, it returns the appropriate error code.
		/// </returns>
		/// <remarks>
		/// <para>Only kernel-mode drivers can call the <c>DbgPrintEx</c> routine.</para>
		/// <para>
		/// <c>DbgPrint</c> and <c>DbgPrintEx</c> can be called at IRQL&lt;=DIRQL. However, Unicode format codes ( <c>%wc</c> and <c>%ws</c>)
		/// can be used only at IRQL = PASSIVE_LEVEL. Also, because the debugger uses interprocess interrupts (IPIs) to communicate with
		/// other processors, calling <c>DbgPrint</c> at IRQL&gt;DIRQL can cause deadlocks.
		/// </para>
		/// <para>
		/// <c>DbgPrintEx</c> either passes the specified string to the kernel debugger or does nothing at all, depending on the values of
		/// <c>ComponentId</c>, <c>Level</c>, and the corresponding component filter masks. For details, see Reading and Filtering Debugging Messages.
		/// </para>
		/// <para>
		/// Unless it is absolutely necessary, you should not obtain a string from user input or another process and pass it to
		/// <c>DbgPrintEx</c>. If you do use a string that you did not create, you must verify that this is a valid format string, and that
		/// the format codes match the argument list in type and quantity. The best coding practice is for all <c>Format</c> strings to be
		/// static and defined at compile time.
		/// </para>
		/// <para>
		/// There is no upper limit to the size of the <c>Format</c> string or the number of arguments. However, any single call to
		/// <c>DbgPrintEx</c> will only transmit 512 bytes of information. There is also a limit to the size of the DbgPrint buffer. See The
		/// DbgPrint Buffer and the Debugger for details.
		/// </para>
		/// </remarks>
		// https://docs.microsoft.com/en-us/windows-hardware/drivers/ddi/wdm/nf-wdm-dbgprintex NTSYSAPI ULONG
		// DbgPrintEx([in] ULONG ComponentId, [in] ULONG Level,[in] PCSTR Format,...);
		[DllImport(Lib.NtDll, SetLastError = false, ExactSpelling = true)]
		[PInvokeData("wdm.h", MSDNShortId = "NF:wdm.DbgPrintEx")]
		public static extern NTStatus DbgPrintEx(DPFLTR_TYPE ComponentId, uint Level, [MarshalAs(UnmanagedType.LPStr)] string Format, [In] IntPtr arguments);

		/// <summary>The <c>DbgPrintEx</c> routine sends a string to the kernel debugger if the conditions you specify are met.</summary>
		/// <param name="ComponentId">
		/// <para>
		/// Specifies the component calling this routine. This must be one of the component name filter IDs defined in the Dpfilter.h header
		/// file. To avoid mixing your driver's output with the output of Windows components, you should use only the following values for <c>ComponentId</c>:
		/// </para>
		/// <list type="bullet">
		/// <item>
		/// <term>DPFLTR_IHVVIDEO_ID</term>
		/// </item>
		/// <item>
		/// <term>DPFLTR_IHVAUDIO_ID</term>
		/// </item>
		/// <item>
		/// <term>DPFLTR_IHVNETWORK_ID</term>
		/// </item>
		/// <item>
		/// <term>DPFLTR_IHVSTREAMING_ID</term>
		/// </item>
		/// <item>
		/// <term>DPFLTR_IHVBUS_ID</term>
		/// </item>
		/// <item>
		/// <term>DPFLTR_IHVDRIVER_ID</term>
		/// </item>
		/// </list>
		/// </param>
		/// <param name="Level">
		/// Specifies the severity of the message being sent. This can be any 32-bit integer. Values between 0 and 31 (inclusive) are treated
		/// differently than values between 32 and 0xFFFFFFFF. For details, see Reading and Filtering Debugging Messages.
		/// </param>
		/// <param name="Format">
		/// Specifies a pointer to the format string to print. The <c>Format</c> string supports most of the <c>printf</c>-style format
		/// specification fields. However, the Unicode format codes ( <c>%C</c>, <c>%S</c>, <c>%lc</c>, <c>%ls</c>, <c>%wc</c>, <c>%ws</c>,
		/// and <c>%wZ</c>) can only be used with IRQL = PASSIVE_LEVEL. The <c>DbgPrintEx</c> routine does not support any of the floating
		/// point types ( <c>%f</c>, <c>%e</c>, <c>%E</c>, <c>%g</c>, <c>%G</c>, <c>%a</c>, or <c>%A</c>).
		/// </param>
		/// <param name="args">Specifies arguments for the format string, as in <c>printf</c>.</param>
		/// <returns>
		/// If successful, <c>DbgPrintEx</c> returns the NTSTATUS code STATUS_SUCCESS; otherwise, it returns the appropriate error code.
		/// </returns>
		/// <remarks>
		/// <para>Only kernel-mode drivers can call the <c>DbgPrintEx</c> routine.</para>
		/// <para>
		/// <c>DbgPrint</c> and <c>DbgPrintEx</c> can be called at IRQL&lt;=DIRQL. However, Unicode format codes ( <c>%wc</c> and <c>%ws</c>)
		/// can be used only at IRQL = PASSIVE_LEVEL. Also, because the debugger uses interprocess interrupts (IPIs) to communicate with
		/// other processors, calling <c>DbgPrint</c> at IRQL&gt;DIRQL can cause deadlocks.
		/// </para>
		/// <para>
		/// <c>DbgPrintEx</c> either passes the specified string to the kernel debugger or does nothing at all, depending on the values of
		/// <c>ComponentId</c>, <c>Level</c>, and the corresponding component filter masks. For details, see Reading and Filtering Debugging Messages.
		/// </para>
		/// <para>
		/// Unless it is absolutely necessary, you should not obtain a string from user input or another process and pass it to
		/// <c>DbgPrintEx</c>. If you do use a string that you did not create, you must verify that this is a valid format string, and that
		/// the format codes match the argument list in type and quantity. The best coding practice is for all <c>Format</c> strings to be
		/// static and defined at compile time.
		/// </para>
		/// <para>
		/// There is no upper limit to the size of the <c>Format</c> string or the number of arguments. However, any single call to
		/// <c>DbgPrintEx</c> will only transmit 512 bytes of information. There is also a limit to the size of the DbgPrint buffer. See The
		/// DbgPrint Buffer and the Debugger for details.
		/// </para>
		/// </remarks>
		[PInvokeData("wdm.h", MSDNShortId = "NF:wdm.DbgPrintEx")]
		public static NTStatus DbgPrintEx(DPFLTR_TYPE ComponentId, uint Level, string Format, params object[] args)
		{
			using var pargs = new SafeHGlobalHandle(InteropExtensions.MarshalObjectsToPtr(args, Marshal.AllocHGlobal, out var sz, true), sz, true);
			return DbgPrintEx(ComponentId, Level, Format, pargs);
		}

		/// <summary>
		/// <para>
		/// The <c>ZwCommitComplete</c> routine notifies KTM that the calling resource manager has finished committing a transaction's data.
		/// </para>
		/// </summary>
		/// <param name="EnlistmentHandle">
		/// <para>
		/// A handle to an enlistment object that was obtained by a previous call to ZwCreateEnlistment or ZwOpenEnlistment. The handle must
		/// have ENLISTMENT_SUBORDINATE_RIGHTS access to the object.
		/// </para>
		/// </param>
		/// <param name="TmVirtualClock">
		/// <para>A pointer to a virtual clock value. This parameter is optional and can be <c>NULL</c>.</para>
		/// </param>
		/// <returns>
		/// <para>
		/// <c>ZwCommitComplete</c> returns STATUS_SUCCESS if the operation succeeds. Otherwise, this routine might return one of the
		/// following values:
		/// </para>
		/// <list type="table">
		/// <listheader>
		/// <term>Return code</term>
		/// <term>Description</term>
		/// </listheader>
		/// <item>
		/// <term>STATUS_OBJECT_TYPE_MISMATCH</term>
		/// <term>The specified handle is not a handle to an enlistment object.</term>
		/// </item>
		/// <item>
		/// <term>STATUS_INVALID_HANDLE</term>
		/// <term>The object handle is invalid.</term>
		/// </item>
		/// <item>
		/// <term>STATUS_ACCESS_DENIED</term>
		/// <term>The caller does not have appropriate access to the enlistment object.</term>
		/// </item>
		/// <item>
		/// <term>STATUS_TRANSACTION_NOT_REQUESTED</term>
		/// <term>The transaction or its enlistment is not in the correct state.</term>
		/// </item>
		/// </list>
		/// <para>The routine might return other NTSTATUS values.</para>
		/// </returns>
		/// <remarks>
		/// <para>A resource manager must call <c>ZwCommitComplete</c> after it has finished servicing a TRANSACTION_NOTIFY_COMMIT notification.</para>
		/// <para>For more information about <c>ZwCommitComplete</c>, see Handling Commit Operations.</para>
		/// <para>
		/// For calls from kernel-mode drivers, the <c>NtXxx</c> and <c>ZwXxx</c> versions of a Windows Native System Services routine can
		/// behave differently in the way that they handle and interpret input parameters. For more information about the relationship
		/// between the <c>NtXxx</c> and <c>ZwXxx</c> versions of a routine, see Using Nt and Zw Versions of the Native System Services Routines.
		/// </para>
		/// </remarks>
		// https://docs.microsoft.com/en-us/windows-hardware/drivers/ddi/content/wdm/nf-wdm-ntcommitcomplete __kernel_entry NTSYSCALLAPI
		// NTSTATUS NtCommitComplete( HANDLE EnlistmentHandle, PLARGE_INTEGER TmVirtualClock );
		[DllImport(Lib.NtDll, SetLastError = false, ExactSpelling = true)]
		[PInvokeData("wdm.h", MSDNShortId = "d0b968bc-bbab-4b6f-bb1f-9e36ac7c1e05")]
		public static extern NTStatus NtCommitComplete([In] SafeEnlistmentHandle EnlistmentHandle, in long TmVirtualClock);

		/// <summary>
		/// <para>
		/// The <c>ZwCommitComplete</c> routine notifies KTM that the calling resource manager has finished committing a transaction's data.
		/// </para>
		/// </summary>
		/// <param name="EnlistmentHandle">
		/// <para>
		/// A handle to an enlistment object that was obtained by a previous call to ZwCreateEnlistment or ZwOpenEnlistment. The handle must
		/// have ENLISTMENT_SUBORDINATE_RIGHTS access to the object.
		/// </para>
		/// </param>
		/// <param name="TmVirtualClock">
		/// <para>A pointer to a virtual clock value. This parameter is optional and can be <c>NULL</c>.</para>
		/// </param>
		/// <returns>
		/// <para>
		/// <c>ZwCommitComplete</c> returns STATUS_SUCCESS if the operation succeeds. Otherwise, this routine might return one of the
		/// following values:
		/// </para>
		/// <list type="table">
		/// <listheader>
		/// <term>Return code</term>
		/// <term>Description</term>
		/// </listheader>
		/// <item>
		/// <term>STATUS_OBJECT_TYPE_MISMATCH</term>
		/// <term>The specified handle is not a handle to an enlistment object.</term>
		/// </item>
		/// <item>
		/// <term>STATUS_INVALID_HANDLE</term>
		/// <term>The object handle is invalid.</term>
		/// </item>
		/// <item>
		/// <term>STATUS_ACCESS_DENIED</term>
		/// <term>The caller does not have appropriate access to the enlistment object.</term>
		/// </item>
		/// <item>
		/// <term>STATUS_TRANSACTION_NOT_REQUESTED</term>
		/// <term>The transaction or its enlistment is not in the correct state.</term>
		/// </item>
		/// </list>
		/// <para>The routine might return other NTSTATUS values.</para>
		/// </returns>
		/// <remarks>
		/// <para>A resource manager must call <c>ZwCommitComplete</c> after it has finished servicing a TRANSACTION_NOTIFY_COMMIT notification.</para>
		/// <para>For more information about <c>ZwCommitComplete</c>, see Handling Commit Operations.</para>
		/// <para>
		/// For calls from kernel-mode drivers, the <c>NtXxx</c> and <c>ZwXxx</c> versions of a Windows Native System Services routine can
		/// behave differently in the way that they handle and interpret input parameters. For more information about the relationship
		/// between the <c>NtXxx</c> and <c>ZwXxx</c> versions of a routine, see Using Nt and Zw Versions of the Native System Services Routines.
		/// </para>
		/// </remarks>
		// https://docs.microsoft.com/en-us/windows-hardware/drivers/ddi/content/wdm/nf-wdm-ntcommitcomplete __kernel_entry NTSYSCALLAPI
		// NTSTATUS NtCommitComplete( HANDLE EnlistmentHandle, PLARGE_INTEGER TmVirtualClock );
		[DllImport(Lib.NtDll, SetLastError = false, ExactSpelling = true)]
		[PInvokeData("wdm.h", MSDNShortId = "d0b968bc-bbab-4b6f-bb1f-9e36ac7c1e05")]
		public static extern NTStatus NtCommitComplete([In] SafeEnlistmentHandle EnlistmentHandle, [In, Optional] IntPtr TmVirtualClock);

		/// <summary>
		/// <para>The <c>ZwCommitEnlistment</c> routine initiates the commit operation for a specified enlistment's transaction.</para>
		/// </summary>
		/// <param name="EnlistmentHandle">
		/// <para>
		/// A handle to an enlistment object that was obtained by a previous call to ZwCreateEnlistment or ZwOpenEnlistment. The object must
		/// represent a superior enlistment and the handle must have ENLISTMENT_SUPERIOR_RIGHTS access to the object.
		/// </para>
		/// </param>
		/// <param name="TmVirtualClock">
		/// <para>A pointer to a virtual clock value. This parameter is optional and can be <c>NULL</c>.</para>
		/// </param>
		/// <returns>
		/// <para>
		/// <c>ZwCommitEnlistment</c> returns STATUS_SUCCESS if the operation succeeds. Otherwise, this routine might return one of the
		/// following values:
		/// </para>
		/// <list type="table">
		/// <listheader>
		/// <term>Return code</term>
		/// <term>Description</term>
		/// </listheader>
		/// <item>
		/// <term>STATUS_OBJECT_TYPE_MISMATCH</term>
		/// <term>The specified handle is not a handle to an enlistment object.</term>
		/// </item>
		/// <item>
		/// <term>STATUS_INVALID_HANDLE</term>
		/// <term>The object handle is invalid.</term>
		/// </item>
		/// <item>
		/// <term>STATUS_ACCESS_DENIED</term>
		/// <term>The caller does not have appropriate access to the enlistment object.</term>
		/// </item>
		/// <item>
		/// <term>STATUS_ENLISTMENT_NOT_SUPERIOR</term>
		/// <term>The caller is not a superior transaction manager for the enlistment.</term>
		/// </item>
		/// <item>
		/// <term>STATUS_TRANSACTION_RESPONSE_NOT_ENLISTED</term>
		/// <term>The caller did not register to receive TRANSACTION_NOTIFY_COMMIT_COMPLETE notifications.</term>
		/// </item>
		/// <item>
		/// <term>STATUS_TRANSACTION_REQUEST_NOT_VALID</term>
		/// <term>The enlistment's transaction is not in a state that allows it to be committed.</term>
		/// </item>
		/// <item>
		/// <term>STATUS_TRANSACTION_NOT_ACTIVE</term>
		/// <term>The commit operation for this transaction has already been started.</term>
		/// </item>
		/// <item>
		/// <term>STATUS_TRANSACTION_ALREADY_ABORTED</term>
		/// <term>The transaction cannot be committed because it has been rolled back.</term>
		/// </item>
		/// </list>
		/// <para>The routine might return other NTSTATUS values.</para>
		/// </returns>
		/// <remarks>
		/// <para>Only superior transaction managers can call <c>ZwCommitEnlistment</c>.</para>
		/// <para>Callers of <c>ZwCommitEnlistment</c> must register to receive TRANSACTION_NOTIFY_COMMIT_COMPLETE notifications.</para>
		/// <para>
		/// The <c>ZwCommitEnlistment</c> routine causes KTM to send TRANSACTION_NOTIFY_COMMIT notifications to all resource managers that
		/// have enlisted in the transaction.
		/// </para>
		/// <para>
		/// For more information about <c>ZwCommitEnlistment</c>, see Creating a Superior Transaction Manager and Handling Commit Operations.
		/// </para>
		/// <para>
		/// For calls from kernel-mode drivers, the <c>NtXxx</c> and <c>ZwXxx</c> versions of a Windows Native System Services routine can
		/// behave differently in the way that they handle and interpret input parameters. For more information about the relationship
		/// between the <c>NtXxx</c> and <c>ZwXxx</c> versions of a routine, see Using Nt and Zw Versions of the Native System Services Routines.
		/// </para>
		/// </remarks>
		// https://docs.microsoft.com/en-us/windows-hardware/drivers/ddi/content/wdm/nf-wdm-ntcommitenlistment __kernel_entry NTSYSCALLAPI
		// NTSTATUS NtCommitEnlistment( HANDLE EnlistmentHandle, PLARGE_INTEGER TmVirtualClock );
		[DllImport(Lib.NtDll, SetLastError = false, ExactSpelling = true)]
		[PInvokeData("wdm.h", MSDNShortId = "9c7f3e24-1d7c-450e-bbef-df0479911bc6")]
		public static extern NTStatus NtCommitEnlistment([In] SafeEnlistmentHandle EnlistmentHandle, in long TmVirtualClock);

		/// <summary>
		/// <para>The <c>ZwCommitEnlistment</c> routine initiates the commit operation for a specified enlistment's transaction.</para>
		/// </summary>
		/// <param name="EnlistmentHandle">
		/// <para>
		/// A handle to an enlistment object that was obtained by a previous call to ZwCreateEnlistment or ZwOpenEnlistment. The object must
		/// represent a superior enlistment and the handle must have ENLISTMENT_SUPERIOR_RIGHTS access to the object.
		/// </para>
		/// </param>
		/// <param name="TmVirtualClock">
		/// <para>A pointer to a virtual clock value. This parameter is optional and can be <c>NULL</c>.</para>
		/// </param>
		/// <returns>
		/// <para>
		/// <c>ZwCommitEnlistment</c> returns STATUS_SUCCESS if the operation succeeds. Otherwise, this routine might return one of the
		/// following values:
		/// </para>
		/// <list type="table">
		/// <listheader>
		/// <term>Return code</term>
		/// <term>Description</term>
		/// </listheader>
		/// <item>
		/// <term>STATUS_OBJECT_TYPE_MISMATCH</term>
		/// <term>The specified handle is not a handle to an enlistment object.</term>
		/// </item>
		/// <item>
		/// <term>STATUS_INVALID_HANDLE</term>
		/// <term>The object handle is invalid.</term>
		/// </item>
		/// <item>
		/// <term>STATUS_ACCESS_DENIED</term>
		/// <term>The caller does not have appropriate access to the enlistment object.</term>
		/// </item>
		/// <item>
		/// <term>STATUS_ENLISTMENT_NOT_SUPERIOR</term>
		/// <term>The caller is not a superior transaction manager for the enlistment.</term>
		/// </item>
		/// <item>
		/// <term>STATUS_TRANSACTION_RESPONSE_NOT_ENLISTED</term>
		/// <term>The caller did not register to receive TRANSACTION_NOTIFY_COMMIT_COMPLETE notifications.</term>
		/// </item>
		/// <item>
		/// <term>STATUS_TRANSACTION_REQUEST_NOT_VALID</term>
		/// <term>The enlistment's transaction is not in a state that allows it to be committed.</term>
		/// </item>
		/// <item>
		/// <term>STATUS_TRANSACTION_NOT_ACTIVE</term>
		/// <term>The commit operation for this transaction has already been started.</term>
		/// </item>
		/// <item>
		/// <term>STATUS_TRANSACTION_ALREADY_ABORTED</term>
		/// <term>The transaction cannot be committed because it has been rolled back.</term>
		/// </item>
		/// </list>
		/// <para>The routine might return other NTSTATUS values.</para>
		/// </returns>
		/// <remarks>
		/// <para>Only superior transaction managers can call <c>ZwCommitEnlistment</c>.</para>
		/// <para>Callers of <c>ZwCommitEnlistment</c> must register to receive TRANSACTION_NOTIFY_COMMIT_COMPLETE notifications.</para>
		/// <para>
		/// The <c>ZwCommitEnlistment</c> routine causes KTM to send TRANSACTION_NOTIFY_COMMIT notifications to all resource managers that
		/// have enlisted in the transaction.
		/// </para>
		/// <para>
		/// For more information about <c>ZwCommitEnlistment</c>, see Creating a Superior Transaction Manager and Handling Commit Operations.
		/// </para>
		/// <para>
		/// For calls from kernel-mode drivers, the <c>NtXxx</c> and <c>ZwXxx</c> versions of a Windows Native System Services routine can
		/// behave differently in the way that they handle and interpret input parameters. For more information about the relationship
		/// between the <c>NtXxx</c> and <c>ZwXxx</c> versions of a routine, see Using Nt and Zw Versions of the Native System Services Routines.
		/// </para>
		/// </remarks>
		// https://docs.microsoft.com/en-us/windows-hardware/drivers/ddi/content/wdm/nf-wdm-ntcommitenlistment __kernel_entry NTSYSCALLAPI
		// NTSTATUS NtCommitEnlistment( HANDLE EnlistmentHandle, PLARGE_INTEGER TmVirtualClock );
		[DllImport(Lib.NtDll, SetLastError = false, ExactSpelling = true)]
		[PInvokeData("wdm.h", MSDNShortId = "9c7f3e24-1d7c-450e-bbef-df0479911bc6")]
		public static extern NTStatus NtCommitEnlistment([In] SafeEnlistmentHandle EnlistmentHandle, [In, Optional] IntPtr TmVirtualClock);

		/// <summary>
		/// <para>The <c>ZwCommitTransaction</c> routine initiates a commit operation for a specified transaction.</para>
		/// </summary>
		/// <param name="TransactionHandle">
		/// <para>
		/// A handle to a transaction object. Your component receives this handle from ZwCreateTransaction or ZwOpenTransaction. The handle
		/// must have TRANSACTION_COMMIT access to the object.
		/// </para>
		/// </param>
		/// <param name="Wait">
		/// <para>
		/// A Boolean value that the caller sets to <c>TRUE</c> for synchronous operation or <c>FALSE</c> for asynchronous operation. If
		/// this parameter is <c>TRUE</c>, the call returns after the commit operation is complete.
		/// </para>
		/// </param>
		/// <returns>
		/// <para>
		/// <c>ZwCommitTransaction</c> returns STATUS_SUCCESS if the operation succeeds. Otherwise, this routine might return one of the
		/// following values:
		/// </para>
		/// <list type="table">
		/// <listheader>
		/// <term>Return code</term>
		/// <term>Description</term>
		/// </listheader>
		/// <item>
		/// <term>STATUS_OBJECT_TYPE_MISMATCH</term>
		/// <term>The handle that was specified for the TransactionHandle parameter is not a handle to a transaction object.</term>
		/// </item>
		/// <item>
		/// <term>STATUS_INVALID_HANDLE</term>
		/// <term>The specified transaction object handle is invalid.</term>
		/// </item>
		/// <item>
		/// <term>STATUS_ACCESS_DENIED</term>
		/// <term>The caller does not have appropriate access to the transaction object.</term>
		/// </item>
		/// <item>
		/// <term>STATUS_TRANSACTION_SUPERIOR_EXISTS</term>
		/// <term>The caller cannot commit the transaction because a superior transaction manager exists.</term>
		/// </item>
		/// <item>
		/// <term>STATUS_TRANSACTION_ALREADY_ABORTED</term>
		/// <term>The transaction cannot be committed because it has been rolled back.</term>
		/// </item>
		/// <item>
		/// <term>STATUS_TRANSACTION_ALREADY_COMMITTED</term>
		/// <term>The transaction is already committed.</term>
		/// </item>
		/// <item>
		/// <term>STATUS_TRANSACTION_REQUEST_NOT_VALID</term>
		/// <term>The commit operation for this transaction has already been started.</term>
		/// </item>
		/// <item>
		/// <term>STATUS_PENDING</term>
		/// <term>Commit notifications have been queued to resource managers, and the caller specified FALSE for the Wait parameter.</term>
		/// </item>
		/// </list>
		/// <para>The routine might return other NTSTATUS values.</para>
		/// </returns>
		/// <remarks>
		/// <para>
		/// For more information about how transaction clients should use the <c>ZwCommitTransaction</c> routine, see Creating a
		/// Transactional Client.
		/// </para>
		/// <para>For more information about commit operations, see Handling Commit Operations.</para>
		/// <para>
		/// For calls from kernel-mode drivers, the <c>NtXxx</c> and <c>ZwXxx</c> versions of a Windows Native System Services routine can
		/// behave differently in the way that they handle and interpret input parameters. For more information about the relationship
		/// between the <c>NtXxx</c> and <c>ZwXxx</c> versions of a routine, see Using Nt and Zw Versions of the Native System Services Routines.
		/// </para>
		/// </remarks>
		// https://docs.microsoft.com/en-us/windows-hardware/drivers/ddi/content/wdm/nf-wdm-ntcommittransaction __kernel_entry NTSYSCALLAPI
		// NTSTATUS NtCommitTransaction( HANDLE TransactionHandle, BOOLEAN Wait );
		[DllImport(Lib.NtDll, SetLastError = false, ExactSpelling = true)]
		[PInvokeData("wdm.h", MSDNShortId = "145646f3-ff90-41d6-bf76-947cdf93b489")]
		public static extern NTStatus NtCommitTransaction([In] IntPtr TransactionHandle, [MarshalAs(UnmanagedType.U1)] bool Wait);

		/// <summary>
		/// <para>The <c>ZwCreateEnlistment</c> routine creates a new enlistment object for a transaction.</para>
		/// </summary>
		/// <param name="EnlistmentHandle">
		/// <para>
		/// A pointer to a caller-allocated variable that receives a handle to the new enlistment object if the call to
		/// <c>ZwCreateEnlistment</c> succeeds.
		/// </para>
		/// </param>
		/// <param name="DesiredAccess">
		/// <para>
		/// An ACCESS_MASK value that specifies the caller's requested access to the enlistment object. In addition to the access rights
		/// that are defined for all kinds of objects (see ACCESS_MASK), the caller can specify any of the following access right flags for
		/// enlistment objects:
		/// </para>
		/// <list type="table">
		/// <listheader>
		/// <term>ACCESS_MASK flag</term>
		/// <term>Allows the caller to</term>
		/// </listheader>
		/// <item>
		/// <term>ENLISTMENT_QUERY_INFORMATION</term>
		/// <term>Query information about the enlistment (see ZwQueryInformationEnlistment).</term>
		/// </item>
		/// <item>
		/// <term>ENLISTMENT_SET_INFORMATION</term>
		/// <term>Set information for the enlistment (see ZwSetInformationEnlistment).</term>
		/// </item>
		/// <item>
		/// <term>ENLISTMENT_RECOVER</term>
		/// <term>Recover the enlistment (see ZwRecoverEnlistment).</term>
		/// </item>
		/// <item>
		/// <term>ENLISTMENT_SUBORDINATE_RIGHTS</term>
		/// <term>
		/// Perform operations that a resource manager that is not superior performs (see ZwRollbackEnlistment, ZwPrePrepareComplete,
		/// ZwPrepareComplete, ZwCommitComplete, ZwRollbackComplete, ZwSinglePhaseReject, ZwReadOnlyEnlistment).
		/// </term>
		/// </item>
		/// <item>
		/// <term>ENLISTMENT_SUPERIOR_RIGHTS</term>
		/// <term>
		/// Perform operations that a superior transaction manager must perform (see ZwPrepareEnlistment, ZwPrePrepareEnlistment, ZwCommitEnlistment).
		/// </term>
		/// </item>
		/// </list>
		/// <para>
		/// Alternatively, you can specify one or more of the following ACCESS_MASK bitmaps. These bitmaps combine the flags from the
		/// previous table with the STANDARD_RIGHTS_XXX flags that are described on the ACCESS_MASK reference page. You can also combine
		/// these bitmaps together with additional flags from the previous table. The following table shows how the bitmaps correspond to
		/// specific access rights.
		/// </para>
		/// <list type="table">
		/// <listheader>
		/// <term>Generic access right</term>
		/// <term>Set of specific access rights</term>
		/// </listheader>
		/// <item>
		/// <term>ENLISTMENT_GENERIC_READ</term>
		/// <term>STANDARD_RIGHTS_READ and ENLISTMENT_QUERY_INFORMATION</term>
		/// </item>
		/// <item>
		/// <term>ENLISTMENT_GENERIC_WRITE</term>
		/// <term>
		/// STANDARD_RIGHTS_WRITE, ENLISTMENT_SET_INFORMATION, ENLISTMENT_RECOVER, ENLISTMENT_REFERENCE, ENLISTMENT_SUBORDINATE_RIGHTS, and ENLISTMENT_SUPERIOR_RIGHTS
		/// </term>
		/// </item>
		/// <item>
		/// <term>ENLISTMENT_GENERIC_EXECUTE</term>
		/// <term>STANDARD_RIGHTS_EXECUTE, ENLISTMENT_RECOVER, ENLISTMENT_SUBORDINATE_RIGHTS, and ENLISTMENT_SUPERIOR_RIGHTS</term>
		/// </item>
		/// <item>
		/// <term>ENLISTMENT_ALL_ACCESS</term>
		/// <term>STANDARD_RIGHTS_REQUIRED, ENLISTMENT_GENERIC_READ, ENLISTMENT_GENERIC_WRITE, and ENLISTMENT_GENERIC_EXECUTE</term>
		/// </item>
		/// </list>
		/// </param>
		/// <param name="ResourceManagerHandle">
		/// <para>A handle to the caller's resource manager object that was obtained by a previous call to ZwCreateResourceManager or ZwOpenResourceManager.</para>
		/// </param>
		/// <param name="TransactionHandle">
		/// <para>
		/// A handle to a transaction object that was obtained by a previous call to ZwCreateTransaction or ZwOpenTransaction. KTM adds this
		/// transaction to the list of transactions that the calling resource manager is handling.
		/// </para>
		/// </param>
		/// <param name="ObjectAttributes">
		/// <para>
		/// A pointer to an OBJECT_ATTRIBUTES structure that specifies the object name and other attributes. Use the
		/// InitializeObjectAttributes routine to initialize this structure. If the caller is not running in a system thread context, it
		/// must set the OBJ_KERNEL_HANDLE attribute when it calls <c>InitializeObjectAttributes</c>. This parameter is optional and can be <c>NULL</c>.
		/// </para>
		/// </param>
		/// <param name="CreateOptions">
		/// <para>Enlistment option flags. The following table contains the only available flag.</para>
		/// <list type="table">
		/// <listheader>
		/// <term>CreateOptions flag</term>
		/// <term>Meaning</term>
		/// </listheader>
		/// <item>
		/// <term>ENLISTMENT_SUPERIOR</term>
		/// <term>The caller is enlisting as a superior transaction manager for the specified transaction.</term>
		/// </item>
		/// </list>
		/// <para>This parameter is optional and can be zero.</para>
		/// </param>
		/// <param name="NotificationMask">
		/// <para>
		/// A bitwise OR of TRANSACTION_NOTIFY_XXX values that are defined in Ktmtypes.h. This mask specifies the types of transaction
		/// notifications that KTM sends to the caller.
		/// </para>
		/// </param>
		/// <param name="EnlistmentKey">
		/// <para>
		/// A pointer to caller-defined information that uniquely identifies the enlistment. The resource manager receives this pointer when
		/// it calls ZwGetNotificationResourceManager or when KTM calls the ResourceManagerNotification callback routine. The resource
		/// manager can maintain a reference count for this key by calling TmReferenceEnlistmentKey and TmDereferenceEnlistmentKey. This
		/// parameter is optional and can be <c>NULL</c>.
		/// </para>
		/// </param>
		/// <returns>
		/// <para>
		/// <c>ZwCreateEnlistment</c> returns STATUS_SUCCESS if the operation succeeds. Otherwise, this routine might return one of the
		/// following values:
		/// </para>
		/// <list type="table">
		/// <listheader>
		/// <term>Return code</term>
		/// <term>Description</term>
		/// </listheader>
		/// <item>
		/// <term>STATUS_INVALID_HANDLE</term>
		/// <term>An object handle is invalid.</term>
		/// </item>
		/// <item>
		/// <term>STATUS_INVALID_PARAMETER</term>
		/// <term>
		/// The CreateOptions or NotificationMask parameter's value is invalid, or KTM could not find the transaction that the
		/// TransactionHandle parameter specifies.
		/// </term>
		/// </item>
		/// <item>
		/// <term>STATUS_INSUFFICIENT_RESOURCES</term>
		/// <term>A memory allocation failed.</term>
		/// </item>
		/// <item>
		/// <term>STATUS_TRANSACTIONMANAGER_NOT_ONLINE</term>
		/// <term>The enlistment failed because KTM or the resource manager is not in an operational state.</term>
		/// </item>
		/// <item>
		/// <term>STATUS_TRANSACTION_NOT_ACTIVE</term>
		/// <term>The enlistment failed because the transaction that the TransactionHandle parameter specifies is not active.</term>
		/// </item>
		/// <item>
		/// <term>STATUS_TRANSACTION_SUPERIOR_EXISTS</term>
		/// <term>The caller tried to register as a superior transaction manager but a superior transaction manager already exists.</term>
		/// </item>
		/// <item>
		/// <term>STATUS_TM_VOLATILE</term>
		/// <term>
		/// The caller is trying to register as a superior transaction manager, but the caller's resource manager object is volatile while
		/// the associated transaction manager object is not volatile.
		/// </term>
		/// </item>
		/// <item>
		/// <term>STATUS_ACCESS_DENIED</term>
		/// <term>The value of the DesiredAccess parameter is invalid.</term>
		/// </item>
		/// </list>
		/// <para>The routine might return other NTSTATUS values.</para>
		/// </returns>
		/// <remarks>
		/// <para>A resource manager calls <c>ZwCreateEnlistment</c> to enlist in a transaction.</para>
		/// <para>Resource managers that are not superior must include the ENLISTMENT_SUBORDINATE_RIGHTS flag in their access mask.</para>
		/// <para>
		/// Superior transaction managers must include the ENLISTMENT_SUPERIOR_RIGHTS flag in their access masks. Typically, a superior
		/// transaction manager includes code that calls ZwRollbackEnlistment, so it must also include the ENLISTMENT_SUBORDINATE_RIGHTS flag.
		/// </para>
		/// <para>A resource manager that calls <c>ZwCreateEnlistment</c> must eventually call ZwClose to close the object handle.</para>
		/// <para>
		/// Your resource manager can use the EnlistmentKey parameter to assign a unique value to each enlistment, such as a pointer to a
		/// data structure that contains information about the enlistment. For example, if the resource manager stores the enlistment
		/// object's handle in the structure, the resource manager can do the following:
		/// </para>
		/// <para>
		/// For more information about <c>ZwCreateEnlistment</c>, see Creating a Resource Manager and Creating a Superior Transaction Manager.
		/// </para>
		/// <para>
		/// For calls from kernel-mode drivers, the <c>NtXxx</c> and <c>ZwXxx</c> versions of a Windows Native System Services routine can
		/// behave differently in the way that they handle and interpret input parameters. For more information about the relationship
		/// between the <c>NtXxx</c> and <c>ZwXxx</c> versions of a routine, see Using Nt and Zw Versions of the Native System Services Routines.
		/// </para>
		/// </remarks>
		// https://docs.microsoft.com/en-us/windows-hardware/drivers/ddi/content/wdm/nf-wdm-ntcreateenlistment __kernel_entry NTSYSCALLAPI
		// NTSTATUS NtCreateEnlistment( PHANDLE EnlistmentHandle, ACCESS_MASK DesiredAccess, HANDLE ResourceManagerHandle, HANDLE
		// TransactionHandle, POBJECT_ATTRIBUTES ObjectAttributes, ULONG CreateOptions, NOTIFICATION_MASK NotificationMask, PVOID
		// EnlistmentKey );
		[DllImport(Lib.NtDll, SetLastError = false, ExactSpelling = true)]
		[PInvokeData("wdm.h", MSDNShortId = "5ffd8262-10b3-4c40-bd3e-050271338508")]
		public static extern NTStatus NtCreateEnlistment(out SafeEnlistmentHandle EnlistmentHandle, ACCESS_MASK DesiredAccess, [In] SafeResourceManagerHandle ResourceManagerHandle,
			[In] SafeTransactionHandle TransactionHandle, in OBJECT_ATTRIBUTES ObjectAttributes, [Optional] uint CreateOptions, NOTIFICATION_MASK NotificationMask, [In, Optional] IntPtr EnlistmentKey);

		/// <summary>
		/// <para>The <c>ZwCreateEnlistment</c> routine creates a new enlistment object for a transaction.</para>
		/// </summary>
		/// <param name="EnlistmentHandle">
		/// <para>
		/// A pointer to a caller-allocated variable that receives a handle to the new enlistment object if the call to
		/// <c>ZwCreateEnlistment</c> succeeds.
		/// </para>
		/// </param>
		/// <param name="DesiredAccess">
		/// <para>
		/// An ACCESS_MASK value that specifies the caller's requested access to the enlistment object. In addition to the access rights
		/// that are defined for all kinds of objects (see ACCESS_MASK), the caller can specify any of the following access right flags for
		/// enlistment objects:
		/// </para>
		/// <list type="table">
		/// <listheader>
		/// <term>ACCESS_MASK flag</term>
		/// <term>Allows the caller to</term>
		/// </listheader>
		/// <item>
		/// <term>ENLISTMENT_QUERY_INFORMATION</term>
		/// <term>Query information about the enlistment (see ZwQueryInformationEnlistment).</term>
		/// </item>
		/// <item>
		/// <term>ENLISTMENT_SET_INFORMATION</term>
		/// <term>Set information for the enlistment (see ZwSetInformationEnlistment).</term>
		/// </item>
		/// <item>
		/// <term>ENLISTMENT_RECOVER</term>
		/// <term>Recover the enlistment (see ZwRecoverEnlistment).</term>
		/// </item>
		/// <item>
		/// <term>ENLISTMENT_SUBORDINATE_RIGHTS</term>
		/// <term>
		/// Perform operations that a resource manager that is not superior performs (see ZwRollbackEnlistment, ZwPrePrepareComplete,
		/// ZwPrepareComplete, ZwCommitComplete, ZwRollbackComplete, ZwSinglePhaseReject, ZwReadOnlyEnlistment).
		/// </term>
		/// </item>
		/// <item>
		/// <term>ENLISTMENT_SUPERIOR_RIGHTS</term>
		/// <term>
		/// Perform operations that a superior transaction manager must perform (see ZwPrepareEnlistment, ZwPrePrepareEnlistment, ZwCommitEnlistment).
		/// </term>
		/// </item>
		/// </list>
		/// <para>
		/// Alternatively, you can specify one or more of the following ACCESS_MASK bitmaps. These bitmaps combine the flags from the
		/// previous table with the STANDARD_RIGHTS_XXX flags that are described on the ACCESS_MASK reference page. You can also combine
		/// these bitmaps together with additional flags from the previous table. The following table shows how the bitmaps correspond to
		/// specific access rights.
		/// </para>
		/// <list type="table">
		/// <listheader>
		/// <term>Generic access right</term>
		/// <term>Set of specific access rights</term>
		/// </listheader>
		/// <item>
		/// <term>ENLISTMENT_GENERIC_READ</term>
		/// <term>STANDARD_RIGHTS_READ and ENLISTMENT_QUERY_INFORMATION</term>
		/// </item>
		/// <item>
		/// <term>ENLISTMENT_GENERIC_WRITE</term>
		/// <term>
		/// STANDARD_RIGHTS_WRITE, ENLISTMENT_SET_INFORMATION, ENLISTMENT_RECOVER, ENLISTMENT_REFERENCE, ENLISTMENT_SUBORDINATE_RIGHTS, and ENLISTMENT_SUPERIOR_RIGHTS
		/// </term>
		/// </item>
		/// <item>
		/// <term>ENLISTMENT_GENERIC_EXECUTE</term>
		/// <term>STANDARD_RIGHTS_EXECUTE, ENLISTMENT_RECOVER, ENLISTMENT_SUBORDINATE_RIGHTS, and ENLISTMENT_SUPERIOR_RIGHTS</term>
		/// </item>
		/// <item>
		/// <term>ENLISTMENT_ALL_ACCESS</term>
		/// <term>STANDARD_RIGHTS_REQUIRED, ENLISTMENT_GENERIC_READ, ENLISTMENT_GENERIC_WRITE, and ENLISTMENT_GENERIC_EXECUTE</term>
		/// </item>
		/// </list>
		/// </param>
		/// <param name="ResourceManagerHandle">
		/// <para>A handle to the caller's resource manager object that was obtained by a previous call to ZwCreateResourceManager or ZwOpenResourceManager.</para>
		/// </param>
		/// <param name="TransactionHandle">
		/// <para>
		/// A handle to a transaction object that was obtained by a previous call to ZwCreateTransaction or ZwOpenTransaction. KTM adds this
		/// transaction to the list of transactions that the calling resource manager is handling.
		/// </para>
		/// </param>
		/// <param name="ObjectAttributes">
		/// <para>
		/// A pointer to an OBJECT_ATTRIBUTES structure that specifies the object name and other attributes. Use the
		/// InitializeObjectAttributes routine to initialize this structure. If the caller is not running in a system thread context, it
		/// must set the OBJ_KERNEL_HANDLE attribute when it calls <c>InitializeObjectAttributes</c>. This parameter is optional and can be <c>NULL</c>.
		/// </para>
		/// </param>
		/// <param name="CreateOptions">
		/// <para>Enlistment option flags. The following table contains the only available flag.</para>
		/// <list type="table">
		/// <listheader>
		/// <term>CreateOptions flag</term>
		/// <term>Meaning</term>
		/// </listheader>
		/// <item>
		/// <term>ENLISTMENT_SUPERIOR</term>
		/// <term>The caller is enlisting as a superior transaction manager for the specified transaction.</term>
		/// </item>
		/// </list>
		/// <para>This parameter is optional and can be zero.</para>
		/// </param>
		/// <param name="NotificationMask">
		/// <para>
		/// A bitwise OR of TRANSACTION_NOTIFY_XXX values that are defined in Ktmtypes.h. This mask specifies the types of transaction
		/// notifications that KTM sends to the caller.
		/// </para>
		/// </param>
		/// <param name="EnlistmentKey">
		/// <para>
		/// A pointer to caller-defined information that uniquely identifies the enlistment. The resource manager receives this pointer when
		/// it calls ZwGetNotificationResourceManager or when KTM calls the ResourceManagerNotification callback routine. The resource
		/// manager can maintain a reference count for this key by calling TmReferenceEnlistmentKey and TmDereferenceEnlistmentKey. This
		/// parameter is optional and can be <c>NULL</c>.
		/// </para>
		/// </param>
		/// <returns>
		/// <para>
		/// <c>ZwCreateEnlistment</c> returns STATUS_SUCCESS if the operation succeeds. Otherwise, this routine might return one of the
		/// following values:
		/// </para>
		/// <list type="table">
		/// <listheader>
		/// <term>Return code</term>
		/// <term>Description</term>
		/// </listheader>
		/// <item>
		/// <term>STATUS_INVALID_HANDLE</term>
		/// <term>An object handle is invalid.</term>
		/// </item>
		/// <item>
		/// <term>STATUS_INVALID_PARAMETER</term>
		/// <term>
		/// The CreateOptions or NotificationMask parameter's value is invalid, or KTM could not find the transaction that the
		/// TransactionHandle parameter specifies.
		/// </term>
		/// </item>
		/// <item>
		/// <term>STATUS_INSUFFICIENT_RESOURCES</term>
		/// <term>A memory allocation failed.</term>
		/// </item>
		/// <item>
		/// <term>STATUS_TRANSACTIONMANAGER_NOT_ONLINE</term>
		/// <term>The enlistment failed because KTM or the resource manager is not in an operational state.</term>
		/// </item>
		/// <item>
		/// <term>STATUS_TRANSACTION_NOT_ACTIVE</term>
		/// <term>The enlistment failed because the transaction that the TransactionHandle parameter specifies is not active.</term>
		/// </item>
		/// <item>
		/// <term>STATUS_TRANSACTION_SUPERIOR_EXISTS</term>
		/// <term>The caller tried to register as a superior transaction manager but a superior transaction manager already exists.</term>
		/// </item>
		/// <item>
		/// <term>STATUS_TM_VOLATILE</term>
		/// <term>
		/// The caller is trying to register as a superior transaction manager, but the caller's resource manager object is volatile while
		/// the associated transaction manager object is not volatile.
		/// </term>
		/// </item>
		/// <item>
		/// <term>STATUS_ACCESS_DENIED</term>
		/// <term>The value of the DesiredAccess parameter is invalid.</term>
		/// </item>
		/// </list>
		/// <para>The routine might return other NTSTATUS values.</para>
		/// </returns>
		/// <remarks>
		/// <para>A resource manager calls <c>ZwCreateEnlistment</c> to enlist in a transaction.</para>
		/// <para>Resource managers that are not superior must include the ENLISTMENT_SUBORDINATE_RIGHTS flag in their access mask.</para>
		/// <para>
		/// Superior transaction managers must include the ENLISTMENT_SUPERIOR_RIGHTS flag in their access masks. Typically, a superior
		/// transaction manager includes code that calls ZwRollbackEnlistment, so it must also include the ENLISTMENT_SUBORDINATE_RIGHTS flag.
		/// </para>
		/// <para>A resource manager that calls <c>ZwCreateEnlistment</c> must eventually call ZwClose to close the object handle.</para>
		/// <para>
		/// Your resource manager can use the EnlistmentKey parameter to assign a unique value to each enlistment, such as a pointer to a
		/// data structure that contains information about the enlistment. For example, if the resource manager stores the enlistment
		/// object's handle in the structure, the resource manager can do the following:
		/// </para>
		/// <para>
		/// For more information about <c>ZwCreateEnlistment</c>, see Creating a Resource Manager and Creating a Superior Transaction Manager.
		/// </para>
		/// <para>
		/// For calls from kernel-mode drivers, the <c>NtXxx</c> and <c>ZwXxx</c> versions of a Windows Native System Services routine can
		/// behave differently in the way that they handle and interpret input parameters. For more information about the relationship
		/// between the <c>NtXxx</c> and <c>ZwXxx</c> versions of a routine, see Using Nt and Zw Versions of the Native System Services Routines.
		/// </para>
		/// </remarks>
		// https://docs.microsoft.com/en-us/windows-hardware/drivers/ddi/content/wdm/nf-wdm-ntcreateenlistment __kernel_entry NTSYSCALLAPI
		// NTSTATUS NtCreateEnlistment( PHANDLE EnlistmentHandle, ACCESS_MASK DesiredAccess, HANDLE ResourceManagerHandle, HANDLE
		// TransactionHandle, POBJECT_ATTRIBUTES ObjectAttributes, ULONG CreateOptions, NOTIFICATION_MASK NotificationMask, PVOID
		// EnlistmentKey );
		[DllImport(Lib.NtDll, SetLastError = false, ExactSpelling = true)]
		[PInvokeData("wdm.h", MSDNShortId = "5ffd8262-10b3-4c40-bd3e-050271338508")]
		public static extern NTStatus NtCreateEnlistment(out SafeEnlistmentHandle EnlistmentHandle, ACCESS_MASK DesiredAccess, [In] SafeResourceManagerHandle ResourceManagerHandle,
			[In] SafeTransactionHandle TransactionHandle, [In, Optional] IntPtr ObjectAttributes, [Optional] uint CreateOptions, NOTIFICATION_MASK NotificationMask, [In, Optional] IntPtr EnlistmentKey);

		/// <summary>
		/// <para>The <c>ZwCreateResourceManager</c> routine creates a resource manager object.</para>
		/// </summary>
		/// <param name="ResourceManagerHandle">
		/// <para>
		/// A pointer to a caller-allocated variable that receives a handle to the new resource manager object if the call to
		/// <c>ZwCreateResourceManager</c> is successful.
		/// </para>
		/// </param>
		/// <param name="DesiredAccess">
		/// <para>
		/// An ACCESS_MASK value that specifies the caller's requested access to the resource manager object. In addition to the access
		/// rights that are defined for all kinds of objects (see <c>ACCESS_MASK</c>), the caller can specify any of the following access
		/// right flags for resource manager objects:
		/// </para>
		/// <list type="table">
		/// <listheader>
		/// <term>ACCESS_MASK flag</term>
		/// <term>Allows the caller to</term>
		/// </listheader>
		/// <item>
		/// <term>RESOURCEMANAGER_ENLIST</term>
		/// <term>Enlist in transactions (see ZwCreateEnlistment).</term>
		/// </item>
		/// <item>
		/// <term>RESOURCEMANAGER_GET_NOTIFICATION</term>
		/// <term>Receive notifications about the transactions that are associated with this resource manager (see ZwGetNotificationResourceManager).</term>
		/// </item>
		/// <item>
		/// <term>RESOURCEMANAGER_REGISTER_PROTOCOL</term>
		/// <term>Not used.</term>
		/// </item>
		/// <item>
		/// <term>RESOURCEMANAGER_QUERY_INFORMATION</term>
		/// <term>Query information about the resource manager (see ZwQueryInformationResourceManager).</term>
		/// </item>
		/// <item>
		/// <term>RESOURCEMANAGER_SET_INFORMATION</term>
		/// <term>Not used.</term>
		/// </item>
		/// <item>
		/// <term>RESOURCEMANAGER_RECOVER</term>
		/// <term>Recover the resource manager (see ZwRecoverResourceManager).</term>
		/// </item>
		/// <item>
		/// <term>RESOURCEMANAGER_COMPLETE_PROPAGATION</term>
		/// <term>Not used.</term>
		/// </item>
		/// </list>
		/// <para>
		/// Alternatively, you can specify one or more of the following generic ACCESS_MASK flags. (The STANDARD_RIGHTS_Xxx flags are
		/// predefined system values that are used to enforce security on system objects.) You can also combine these generic flags with
		/// additional flags from the preceding table. The following table shows how generic access rights correspond to specific access rights.
		/// </para>
		/// <list type="table">
		/// <listheader>
		/// <term>Generic access right</term>
		/// <term>Set of specific access rights</term>
		/// </listheader>
		/// <item>
		/// <term>RESOURCEMANAGER_GENERIC_READ</term>
		/// <term>STANDARD_RIGHTS_READ, RESOURCEMANAGER_QUERY_INFORMATION, and SYNCHRONIZE</term>
		/// </item>
		/// <item>
		/// <term>RESOURCEMANAGER_GENERIC_WRITE</term>
		/// <term>
		/// STANDARD_RIGHTS_WRITE, RESOURCEMANAGER_SET_INFORMATION, RESOURCEMANAGER_RECOVER, RESOURCEMANAGER_ENLIST,
		/// RESOURCEMANAGER_GET_NOTIFICATION, RESOURCEMANAGER_REGISTER_PROTOCOL, RESOURCEMANAGER_COMPLETE_PROPAGATION, and SYNCHRONIZE
		/// </term>
		/// </item>
		/// <item>
		/// <term>RESOURCEMANAGER_GENERIC_EXECUTE</term>
		/// <term>
		/// STANDARD_RIGHTS_EXECUTE, RESOURCEMANAGER_RECOVER, RESOURCEMANAGER_ENLIST, RESOURCEMANAGER_GET_NOTIFICATION,
		/// RESOURCEMANAGER_COMPLETE_PROPAGATION, and SYNCHRONIZE
		/// </term>
		/// </item>
		/// <item>
		/// <term>RESOURCEMANAGER_ALL_ACCESS</term>
		/// <term>STANDARD_RIGHTS_REQUIRED, RESOURCEMANAGER_GENERIC_READ, RESOURCEMANAGER_GENERIC_WRITE, and RESOURCEMANAGER_GENERIC_EXECUTE</term>
		/// </item>
		/// </list>
		/// </param>
		/// <param name="TmHandle">
		/// <para>A handle to a transaction manager object that was obtained by a previous all to ZwCreateTransactionManager or ZwOpenTransactionManager.</para>
		/// </param>
		/// <param name="RmGuid">
		/// <para>
		/// A pointer to a GUID that KTM will use to identify the resource manager. If this pointer is <c>NULL</c>, KTM generates a GUID.
		/// </para>
		/// </param>
		/// <param name="ObjectAttributes">
		/// <para>
		/// A pointer to an OBJECT_ATTRIBUTES structure that specifies the object name and other attributes. Use the
		/// InitializeObjectAttributes routine to initialize this structure. If the caller is not running in a system thread context, it
		/// must set the OBJ_KERNEL_HANDLE attribute when it calls <c>InitializeObjectAttributes</c>. This parameter is optional and can be <c>NULL</c>.
		/// </para>
		/// </param>
		/// <param name="CreateOptions">
		/// <para>Optional object creation flags. The following table contains the available flags, which are defined in Ktmtypes.h.</para>
		/// <list type="table">
		/// <listheader>
		/// <term>CreateOptions flag</term>
		/// <term>Meaning</term>
		/// </listheader>
		/// <item>
		/// <term>RESOURCE_MANAGER_COMMUNICATION</term>
		/// <term>For internal use only.</term>
		/// </item>
		/// <item>
		/// <term>RESOURCE_MANAGER_VOLATILE</term>
		/// <term>The caller will manage volatile resources. It will be non-persistent and will not perform recovery.</term>
		/// </item>
		/// </list>
		/// <para>This parameter is optional and can be zero.</para>
		/// </param>
		/// <param name="Description">
		/// <para>
		/// A pointer to a caller-supplied UNICODE_STRING structure that contains a NULL-terminated string. The string provides a
		/// description of the resource manager. KTM stores a copy of the string and includes the string in messages that it writes to the
		/// log stream. The maximum string length is MAX_RESOURCEMANAGER_DESCRIPTION_LENGTH. This parameter is optional and can be <c>NULL</c>.
		/// </para>
		/// </param>
		/// <returns>
		/// <para>
		/// <c>ZwCreateResourceManager</c> returns STATUS_SUCCESS if the operation succeeds. Otherwise, this routine might return one of the
		/// following values:
		/// </para>
		/// <list type="table">
		/// <listheader>
		/// <term>Return code</term>
		/// <term>Description</term>
		/// </listheader>
		/// <item>
		/// <term>STATUS_OBJECT_TYPE_MISMATCH</term>
		/// <term>The handle that TmHandle specifies is not a handle to a transaction object.</term>
		/// </item>
		/// <item>
		/// <term>STATUS_INVALID_HANDLE</term>
		/// <term>The handle that TmHandle specifies is invalid.</term>
		/// </item>
		/// <item>
		/// <term>STATUS_ACCESS_DENIED</term>
		/// <term>The caller does not have appropriate access to the specified transaction manager object.</term>
		/// </item>
		/// <item>
		/// <term>STATUS_TRANSACTION_OBJECT_EXPIRED</term>
		/// <term>The handle that TmHandle specifies is closed.</term>
		/// </item>
		/// <item>
		/// <term>STATUS_INVALID_PARAMETER</term>
		/// <term>The CreateOptions parameter's value is invalid or the Description parameter's string is too long.</term>
		/// </item>
		/// <item>
		/// <term>STATUS_TM_VOLATILE</term>
		/// <term>
		/// The CreateOptions parameter does not specify RESOURCE_MANAGER_VOLATILE but the transaction manager that TmHandle specifies is volatile.
		/// </term>
		/// </item>
		/// <item>
		/// <term>STATUS_OBJECT_NAME_COLLISION</term>
		/// <term>The GUID that ResourceManagerGuid specifies already exists.</term>
		/// </item>
		/// <item>
		/// <term>STATUS_ACCESS_DENIED</term>
		/// <term>The value of the DesiredAccess parameter is invalid.</term>
		/// </item>
		/// </list>
		/// <para>The routine might return other NTSTATUS values.</para>
		/// </returns>
		/// <remarks>
		/// <para>A resource manager that calls <c>ZwCreateResourceManager</c> must eventually call ZwClose to close the object handle.</para>
		/// <para>For more information about <c>ZwCreateResourceManager</c>, see Creating a Resource Manager.</para>
		/// <para>
		/// For calls from kernel-mode drivers, the <c>NtXxx</c> and <c>ZwXxx</c> versions of a Windows Native System Services routine can
		/// behave differently in the way that they handle and interpret input parameters. For more information about the relationship
		/// between the <c>NtXxx</c> and <c>ZwXxx</c> versions of a routine, see Using Nt and Zw Versions of the Native System Services Routines.
		/// </para>
		/// </remarks>
		// https://docs.microsoft.com/en-us/windows-hardware/drivers/ddi/content/wdm/nf-wdm-ntcreateresourcemanager __kernel_entry
		// NTSYSCALLAPI NTSTATUS NtCreateResourceManager( PHANDLE ResourceManagerHandle, ACCESS_MASK DesiredAccess, HANDLE TmHandle, LPGUID
		// RmGuid, POBJECT_ATTRIBUTES ObjectAttributes, ULONG CreateOptions, PUNICODE_STRING Description );
		[DllImport(Lib.NtDll, SetLastError = false, ExactSpelling = true)]
		[PInvokeData("wdm.h", MSDNShortId = "4812eeb4-134f-4ecb-870b-dbab04c1137b")]
		public static extern NTStatus NtCreateResourceManager(out SafeResourceManagerHandle ResourceManagerHandle, ACCESS_MASK DesiredAccess, SafeTransactionManagerHandle TmHandle, in Guid RmGuid,
			in OBJECT_ATTRIBUTES ObjectAttributes, [Optional] uint CreateOptions, [In, Optional, MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UnicodeStringMarshaler))] string Description);

		/// <summary>
		/// <para>The <c>ZwCreateResourceManager</c> routine creates a resource manager object.</para>
		/// </summary>
		/// <param name="ResourceManagerHandle">
		/// <para>
		/// A pointer to a caller-allocated variable that receives a handle to the new resource manager object if the call to
		/// <c>ZwCreateResourceManager</c> is successful.
		/// </para>
		/// </param>
		/// <param name="DesiredAccess">
		/// <para>
		/// An ACCESS_MASK value that specifies the caller's requested access to the resource manager object. In addition to the access
		/// rights that are defined for all kinds of objects (see <c>ACCESS_MASK</c>), the caller can specify any of the following access
		/// right flags for resource manager objects:
		/// </para>
		/// <list type="table">
		/// <listheader>
		/// <term>ACCESS_MASK flag</term>
		/// <term>Allows the caller to</term>
		/// </listheader>
		/// <item>
		/// <term>RESOURCEMANAGER_ENLIST</term>
		/// <term>Enlist in transactions (see ZwCreateEnlistment).</term>
		/// </item>
		/// <item>
		/// <term>RESOURCEMANAGER_GET_NOTIFICATION</term>
		/// <term>Receive notifications about the transactions that are associated with this resource manager (see ZwGetNotificationResourceManager).</term>
		/// </item>
		/// <item>
		/// <term>RESOURCEMANAGER_REGISTER_PROTOCOL</term>
		/// <term>Not used.</term>
		/// </item>
		/// <item>
		/// <term>RESOURCEMANAGER_QUERY_INFORMATION</term>
		/// <term>Query information about the resource manager (see ZwQueryInformationResourceManager).</term>
		/// </item>
		/// <item>
		/// <term>RESOURCEMANAGER_SET_INFORMATION</term>
		/// <term>Not used.</term>
		/// </item>
		/// <item>
		/// <term>RESOURCEMANAGER_RECOVER</term>
		/// <term>Recover the resource manager (see ZwRecoverResourceManager).</term>
		/// </item>
		/// <item>
		/// <term>RESOURCEMANAGER_COMPLETE_PROPAGATION</term>
		/// <term>Not used.</term>
		/// </item>
		/// </list>
		/// <para>
		/// Alternatively, you can specify one or more of the following generic ACCESS_MASK flags. (The STANDARD_RIGHTS_Xxx flags are
		/// predefined system values that are used to enforce security on system objects.) You can also combine these generic flags with
		/// additional flags from the preceding table. The following table shows how generic access rights correspond to specific access rights.
		/// </para>
		/// <list type="table">
		/// <listheader>
		/// <term>Generic access right</term>
		/// <term>Set of specific access rights</term>
		/// </listheader>
		/// <item>
		/// <term>RESOURCEMANAGER_GENERIC_READ</term>
		/// <term>STANDARD_RIGHTS_READ, RESOURCEMANAGER_QUERY_INFORMATION, and SYNCHRONIZE</term>
		/// </item>
		/// <item>
		/// <term>RESOURCEMANAGER_GENERIC_WRITE</term>
		/// <term>
		/// STANDARD_RIGHTS_WRITE, RESOURCEMANAGER_SET_INFORMATION, RESOURCEMANAGER_RECOVER, RESOURCEMANAGER_ENLIST,
		/// RESOURCEMANAGER_GET_NOTIFICATION, RESOURCEMANAGER_REGISTER_PROTOCOL, RESOURCEMANAGER_COMPLETE_PROPAGATION, and SYNCHRONIZE
		/// </term>
		/// </item>
		/// <item>
		/// <term>RESOURCEMANAGER_GENERIC_EXECUTE</term>
		/// <term>
		/// STANDARD_RIGHTS_EXECUTE, RESOURCEMANAGER_RECOVER, RESOURCEMANAGER_ENLIST, RESOURCEMANAGER_GET_NOTIFICATION,
		/// RESOURCEMANAGER_COMPLETE_PROPAGATION, and SYNCHRONIZE
		/// </term>
		/// </item>
		/// <item>
		/// <term>RESOURCEMANAGER_ALL_ACCESS</term>
		/// <term>STANDARD_RIGHTS_REQUIRED, RESOURCEMANAGER_GENERIC_READ, RESOURCEMANAGER_GENERIC_WRITE, and RESOURCEMANAGER_GENERIC_EXECUTE</term>
		/// </item>
		/// </list>
		/// </param>
		/// <param name="TmHandle">
		/// <para>A handle to a transaction manager object that was obtained by a previous all to ZwCreateTransactionManager or ZwOpenTransactionManager.</para>
		/// </param>
		/// <param name="RmGuid">
		/// <para>
		/// A pointer to a GUID that KTM will use to identify the resource manager. If this pointer is <c>NULL</c>, KTM generates a GUID.
		/// </para>
		/// </param>
		/// <param name="ObjectAttributes">
		/// <para>
		/// A pointer to an OBJECT_ATTRIBUTES structure that specifies the object name and other attributes. Use the
		/// InitializeObjectAttributes routine to initialize this structure. If the caller is not running in a system thread context, it
		/// must set the OBJ_KERNEL_HANDLE attribute when it calls <c>InitializeObjectAttributes</c>. This parameter is optional and can be <c>NULL</c>.
		/// </para>
		/// </param>
		/// <param name="CreateOptions">
		/// <para>Optional object creation flags. The following table contains the available flags, which are defined in Ktmtypes.h.</para>
		/// <list type="table">
		/// <listheader>
		/// <term>CreateOptions flag</term>
		/// <term>Meaning</term>
		/// </listheader>
		/// <item>
		/// <term>RESOURCE_MANAGER_COMMUNICATION</term>
		/// <term>For internal use only.</term>
		/// </item>
		/// <item>
		/// <term>RESOURCE_MANAGER_VOLATILE</term>
		/// <term>The caller will manage volatile resources. It will be non-persistent and will not perform recovery.</term>
		/// </item>
		/// </list>
		/// <para>This parameter is optional and can be zero.</para>
		/// </param>
		/// <param name="Description">
		/// <para>
		/// A pointer to a caller-supplied UNICODE_STRING structure that contains a NULL-terminated string. The string provides a
		/// description of the resource manager. KTM stores a copy of the string and includes the string in messages that it writes to the
		/// log stream. The maximum string length is MAX_RESOURCEMANAGER_DESCRIPTION_LENGTH. This parameter is optional and can be <c>NULL</c>.
		/// </para>
		/// </param>
		/// <returns>
		/// <para>
		/// <c>ZwCreateResourceManager</c> returns STATUS_SUCCESS if the operation succeeds. Otherwise, this routine might return one of the
		/// following values:
		/// </para>
		/// <list type="table">
		/// <listheader>
		/// <term>Return code</term>
		/// <term>Description</term>
		/// </listheader>
		/// <item>
		/// <term>STATUS_OBJECT_TYPE_MISMATCH</term>
		/// <term>The handle that TmHandle specifies is not a handle to a transaction object.</term>
		/// </item>
		/// <item>
		/// <term>STATUS_INVALID_HANDLE</term>
		/// <term>The handle that TmHandle specifies is invalid.</term>
		/// </item>
		/// <item>
		/// <term>STATUS_ACCESS_DENIED</term>
		/// <term>The caller does not have appropriate access to the specified transaction manager object.</term>
		/// </item>
		/// <item>
		/// <term>STATUS_TRANSACTION_OBJECT_EXPIRED</term>
		/// <term>The handle that TmHandle specifies is closed.</term>
		/// </item>
		/// <item>
		/// <term>STATUS_INVALID_PARAMETER</term>
		/// <term>The CreateOptions parameter's value is invalid or the Description parameter's string is too long.</term>
		/// </item>
		/// <item>
		/// <term>STATUS_TM_VOLATILE</term>
		/// <term>
		/// The CreateOptions parameter does not specify RESOURCE_MANAGER_VOLATILE but the transaction manager that TmHandle specifies is volatile.
		/// </term>
		/// </item>
		/// <item>
		/// <term>STATUS_OBJECT_NAME_COLLISION</term>
		/// <term>The GUID that ResourceManagerGuid specifies already exists.</term>
		/// </item>
		/// <item>
		/// <term>STATUS_ACCESS_DENIED</term>
		/// <term>The value of the DesiredAccess parameter is invalid.</term>
		/// </item>
		/// </list>
		/// <para>The routine might return other NTSTATUS values.</para>
		/// </returns>
		/// <remarks>
		/// <para>A resource manager that calls <c>ZwCreateResourceManager</c> must eventually call ZwClose to close the object handle.</para>
		/// <para>For more information about <c>ZwCreateResourceManager</c>, see Creating a Resource Manager.</para>
		/// <para>
		/// For calls from kernel-mode drivers, the <c>NtXxx</c> and <c>ZwXxx</c> versions of a Windows Native System Services routine can
		/// behave differently in the way that they handle and interpret input parameters. For more information about the relationship
		/// between the <c>NtXxx</c> and <c>ZwXxx</c> versions of a routine, see Using Nt and Zw Versions of the Native System Services Routines.
		/// </para>
		/// </remarks>
		// https://docs.microsoft.com/en-us/windows-hardware/drivers/ddi/content/wdm/nf-wdm-ntcreateresourcemanager __kernel_entry
		// NTSYSCALLAPI NTSTATUS NtCreateResourceManager( PHANDLE ResourceManagerHandle, ACCESS_MASK DesiredAccess, HANDLE TmHandle, LPGUID
		// RmGuid, POBJECT_ATTRIBUTES ObjectAttributes, ULONG CreateOptions, PUNICODE_STRING Description );
		[DllImport(Lib.NtDll, SetLastError = false, ExactSpelling = true)]
		[PInvokeData("wdm.h", MSDNShortId = "4812eeb4-134f-4ecb-870b-dbab04c1137b")]
		public static extern NTStatus NtCreateResourceManager(out SafeResourceManagerHandle ResourceManagerHandle, ACCESS_MASK DesiredAccess, SafeTransactionManagerHandle TmHandle, in Guid RmGuid,
			[In, Optional] IntPtr ObjectAttributes, [Optional] uint CreateOptions, [In, Optional, MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UnicodeStringMarshaler))] string Description);

		/// <summary>
		/// <para>The <c>ZwCreateTransaction</c> routine creates a transaction object.</para>
		/// </summary>
		/// <param name="TransactionHandle">
		/// <para>
		/// A pointer to a caller-allocated variable that receives a handle to the new transaction object, if the call to
		/// <c>ZwCreateTransaction</c> succeeds.
		/// </para>
		/// </param>
		/// <param name="DesiredAccess">
		/// <para>
		/// An ACCESS_MASK value that specifies the caller's requested access to the transaction object. In addition to the access rights
		/// that are defined for all kinds of objects (see ACCESS_MASK), the caller can specify any of the following flags for transaction objects.
		/// </para>
		/// <list type="table">
		/// <listheader>
		/// <term>Access mask</term>
		/// <term>Allows the caller to</term>
		/// </listheader>
		/// <item>
		/// <term>TRANSACTION_COMMIT</term>
		/// <term>Commit the transaction (see ZwCommitTransaction).</term>
		/// </item>
		/// <item>
		/// <term>TRANSACTION_ENLIST</term>
		/// <term>Create an enlistment for the transaction (see ZwCreateEnlistment).</term>
		/// </item>
		/// <item>
		/// <term>TRANSACTION_PROPAGATE</term>
		/// <term>Do not use.</term>
		/// </item>
		/// <item>
		/// <term>TRANSACTION_QUERY_INFORMATION</term>
		/// <term>Obtain information about the transaction (see ZwQueryInformationTransaction).</term>
		/// </item>
		/// <item>
		/// <term>TRANSACTION_ROLLBACK</term>
		/// <term>Roll back the transaction (see ZwRollbackTransaction).</term>
		/// </item>
		/// <item>
		/// <term>TRANSACTION_SET_INFORMATION</term>
		/// <term>Set information for the transaction (see ZwSetInformationTransaction).</term>
		/// </item>
		/// </list>
		/// <para>
		/// Alternatively, you can specify one or more of the following ACCESS_MASK bitmaps. These bitmaps combine the flags from the
		/// previous table with the STANDARD_RIGHTS_XXX flags that are described on the ACCESS_MASK reference page. You can also combine
		/// these bitmaps with additional flags from the preceding table. The following table shows how the bitmaps correspond to specific
		/// access rights.
		/// </para>
		/// <list type="table">
		/// <listheader>
		/// <term>Rights bitmap</term>
		/// <term>Set of specific access rights</term>
		/// </listheader>
		/// <item>
		/// <term>TRANSACTION_GENERIC_READ</term>
		/// <term>STANDARD_RIGHTS_READ, TRANSACTION_QUERY_INFORMATION, and SYNCHRONIZE</term>
		/// </item>
		/// <item>
		/// <term>TRANSACTION_GENERIC_WRITE</term>
		/// <term>
		/// STANDARD_RIGHTS_WRITE, TRANSACTION_SET_INFORMATION, TRANSACTION_COMMIT, TRANSACTION_ENLIST, TRANSACTION_ROLLBACK,
		/// TRANSACTION_PROPAGATE, TRANSACTION_SAVEPOINT, and SYNCHRONIZE
		/// </term>
		/// </item>
		/// <item>
		/// <term>TRANSACTION_GENERIC_EXECUTE</term>
		/// <term>STANDARD_RIGHTS_EXECUTE, TRANSACTION_COMMIT, TRANSACTION_ROLLBACK, and SYNCHRONIZE</term>
		/// </item>
		/// <item>
		/// <term>TRANSACTION_ALL_ACCESS</term>
		/// <term>STANDARD_RIGHTS_REQUIRED, TRANSACTION_GENERIC_READ, TRANSACTION_GENERIC_WRITE, and TRANSACTION_GENERIC_EXECUTE</term>
		/// </item>
		/// <item>
		/// <term>TRANSACTION_RESOURCE_MANAGER_RIGHTS</term>
		/// <term>
		/// STANDARD_RIGHTS_WRITE, TRANSACTION_GENERIC_READ, TRANSACTION_SET_INFORMATION, TRANSACTION_ENLIST, TRANSACTION_ROLLBACK,
		/// TRANSACTION_PROPAGATE, and SYNCHRONIZE
		/// </term>
		/// </item>
		/// </list>
		/// <para>Typically, a resource manager specifies TRANSACTION_RESOURCE_MANAGER_RIGHTS.</para>
		/// <para>The DesiredAccess value cannot be zero.</para>
		/// </param>
		/// <param name="ObjectAttributes">
		/// <para>
		/// A pointer to an OBJECT_ATTRIBUTES structure that specifies the object name and other attributes. Use the
		/// InitializeObjectAttributes routine to initialize this structure. If the caller is not running in a system thread context, it
		/// must set the OBJ_KERNEL_HANDLE attribute when it calls <c>InitializeObjectAttributes</c>. This parameter is optional and can be <c>NULL</c>.
		/// </para>
		/// </param>
		/// <param name="Uow">
		/// <para>
		/// A pointer to a GUID that KTM uses as the new transaction object's unit of work (UOW) identifier. This parameter is optional and
		/// can be <c>NULL</c>. If this parameter is <c>NULL</c>, KTM generates a GUID and assigns it to the transaction object. For more
		/// information, see the following Remarks section.
		/// </para>
		/// </param>
		/// <param name="TmHandle">
		/// <para>
		/// A handle to a transaction manager object that was obtained by a previous call to ZwCreateTransactionManager or
		/// ZwOpenTransactionManager. KTM assigns the new transaction object to the specified transaction manager object. If this parameter
		/// is <c>NULL</c>, KTM assigns the new transaction object to a transaction manager later, when a resource manager creates an
		/// enlistment for the transaction.
		/// </para>
		/// </param>
		/// <param name="CreateOptions">
		/// <para>Optional object creation flags. The following table contains the available flags, which are defined in Ktmtypes.h.</para>
		/// <list type="table">
		/// <listheader>
		/// <term>Option flag</term>
		/// <term>Meaning</term>
		/// </listheader>
		/// <item>
		/// <term>TRANSACTION_DO_NOT_PROMOTE</term>
		/// <term>Reserved for future use.</term>
		/// </item>
		/// </list>
		/// </param>
		/// <param name="IsolationLevel">
		/// <para>Reserved for future use. Callers must set this parameter to zero.</para>
		/// </param>
		/// <param name="IsolationFlags">
		/// <para>Reserved for future use. Callers should set this parameter to zero.</para>
		/// </param>
		/// <param name="Timeout">
		/// <para>
		/// A pointer to a time-out value. If the transaction has not been committed by the time specified by this parameter, KTM rolls back
		/// the transaction. The time-out value is expressed in system time units (100-nanosecond intervals), and can specify either an
		/// absolute time or a relative time. If the value pointed to by Timeout is negative, the expiration time is relative to the current
		/// system time. Otherwise, the expiration time is absolute. This pointer is optional and can be <c>NULL</c> if you do not want the
		/// transaction to have a time-out value. If Timeout = <c>NULL</c> or *Timeout = 0, the transaction never times out. (You can also
		/// use ZwSetInformationTransaction to set a time-out value.)
		/// </para>
		/// </param>
		/// <param name="Description">
		/// <para>
		/// A pointer to a caller-supplied UNICODE_STRING structure that contains a NULL-terminated string. The string provides a
		/// description of the transaction. KTM stores a copy of the string and includes the string in messages that it writes to the log
		/// stream. The maximum string length is MAX_TRANSACTION_DESCRIPTION_LENGTH. This parameter is optional and can be <c>NULL</c>.
		/// </para>
		/// </param>
		/// <returns>
		/// <para>
		/// <c>ZwCreateTransaction</c> returns STATUS_SUCCESS if the operation succeeds. Otherwise, this routine might return one of the
		/// following values:
		/// </para>
		/// <list type="table">
		/// <listheader>
		/// <term>Return code</term>
		/// <term>Description</term>
		/// </listheader>
		/// <item>
		/// <term>STATUS_INVALID_PARAMETER</term>
		/// <term>
		/// The CreateOptions parameter contains an invalid flag, the DesiredAccess parameter is zero, or the Description parameter's string
		/// is too long.
		/// </term>
		/// </item>
		/// <item>
		/// <term>STATUS_INSUFFICIENT_RESOURCES</term>
		/// <term>KTM could not allocate system resources (typically memory).</term>
		/// </item>
		/// <item>
		/// <term>STATUS_INVALID_ACL</term>
		/// <term>A security descriptor contains an invalid access control list (ACL).</term>
		/// </item>
		/// <item>
		/// <term>STATUS_INVALID_SID</term>
		/// <term>A security descriptor contains an invalid security identifier (SID).</term>
		/// </item>
		/// <item>
		/// <term>STATUS_OBJECT_NAME_EXISTS</term>
		/// <term>The object name that the ObjectAttributes parameter specifies already exists.</term>
		/// </item>
		/// <item>
		/// <term>STATUS_OBJECT_NAME_INVALID</term>
		/// <term>The object name that the ObjectAttributes parameter specifies is invalid.</term>
		/// </item>
		/// <item>
		/// <term>STATUS_ACCESS_DENIED</term>
		/// <term>The value of the DesiredAccess parameter is invalid.</term>
		/// </item>
		/// </list>
		/// <para>The routine might return other NTSTATUS values.</para>
		/// </returns>
		/// <remarks>
		/// <para>
		/// The caller can use the Uow parameter to specify a UOW identifier for the transaction object. If the caller does not specify a
		/// UOW identifier, KTM generates a GUID and assigns it to the transaction object. The caller can later obtain this GUID by calling ZwQueryInformationTransaction.
		/// </para>
		/// <para>
		/// Typically, you should let KTM generate a GUID for the transaction object, unless your component communicates with another TPS
		/// component that has already generated a UOW identifier for the transaction.
		/// </para>
		/// <para>
		/// To close the transaction handle, the component that called <c>ZwCreateTransaction</c> must call ZwClose. If the last transaction
		/// handle closes before any component calls ZwCommitTransaction for the transaction, KTM rolls back the transaction.
		/// </para>
		/// <para>
		/// For more information about how transaction clients should use <c>ZwCreateTransaction</c>, see Creating a Transactional Client.
		/// </para>
		/// <para>
		/// For calls from kernel-mode drivers, the <c>NtXxx</c> and <c>ZwXxx</c> versions of a Windows Native System Services routine can
		/// behave differently in the way that they handle and interpret input parameters. For more information about the relationship
		/// between the <c>NtXxx</c> and <c>ZwXxx</c> versions of a routine, see Using Nt and Zw Versions of the Native System Services Routines.
		/// </para>
		/// </remarks>
		// https://docs.microsoft.com/en-us/windows-hardware/drivers/ddi/content/wdm/nf-wdm-ntcreatetransaction __kernel_entry NTSYSCALLAPI
		// NTSTATUS NtCreateTransaction( PHANDLE TransactionHandle, ACCESS_MASK DesiredAccess, POBJECT_ATTRIBUTES ObjectAttributes, LPGUID
		// Uow, HANDLE TmHandle, ULONG CreateOptions, ULONG IsolationLevel, ULONG IsolationFlags, PLARGE_INTEGER Timeout, PUNICODE_STRING
		// Description );
		[DllImport(Lib.NtDll, SetLastError = false, CharSet = CharSet.Auto)]
		[PInvokeData("wdm.h", MSDNShortId = "b4c2dd68-3c1a-46d3-ab9c-be2291ed80f4")]
		public static extern NTStatus NtCreateTransaction(out SafeTransactionHandle TransactionHandle, ACCESS_MASK DesiredAccess, in OBJECT_ATTRIBUTES ObjectAttributes,
			in Guid Uow, SafeTransactionManagerHandle TmHandle, [Optional] uint CreateOptions, [Optional] uint IsolationLevel, [Optional] uint IsolationFlags, in long Timeout,
			[In, Optional, MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UnicodeStringMarshaler))] string Description);

		/// <summary>
		/// <para>The <c>ZwCreateTransaction</c> routine creates a transaction object.</para>
		/// </summary>
		/// <param name="TransactionHandle">
		/// <para>
		/// A pointer to a caller-allocated variable that receives a handle to the new transaction object, if the call to
		/// <c>ZwCreateTransaction</c> succeeds.
		/// </para>
		/// </param>
		/// <param name="DesiredAccess">
		/// <para>
		/// An ACCESS_MASK value that specifies the caller's requested access to the transaction object. In addition to the access rights
		/// that are defined for all kinds of objects (see ACCESS_MASK), the caller can specify any of the following flags for transaction objects.
		/// </para>
		/// <list type="table">
		/// <listheader>
		/// <term>Access mask</term>
		/// <term>Allows the caller to</term>
		/// </listheader>
		/// <item>
		/// <term>TRANSACTION_COMMIT</term>
		/// <term>Commit the transaction (see ZwCommitTransaction).</term>
		/// </item>
		/// <item>
		/// <term>TRANSACTION_ENLIST</term>
		/// <term>Create an enlistment for the transaction (see ZwCreateEnlistment).</term>
		/// </item>
		/// <item>
		/// <term>TRANSACTION_PROPAGATE</term>
		/// <term>Do not use.</term>
		/// </item>
		/// <item>
		/// <term>TRANSACTION_QUERY_INFORMATION</term>
		/// <term>Obtain information about the transaction (see ZwQueryInformationTransaction).</term>
		/// </item>
		/// <item>
		/// <term>TRANSACTION_ROLLBACK</term>
		/// <term>Roll back the transaction (see ZwRollbackTransaction).</term>
		/// </item>
		/// <item>
		/// <term>TRANSACTION_SET_INFORMATION</term>
		/// <term>Set information for the transaction (see ZwSetInformationTransaction).</term>
		/// </item>
		/// </list>
		/// <para>
		/// Alternatively, you can specify one or more of the following ACCESS_MASK bitmaps. These bitmaps combine the flags from the
		/// previous table with the STANDARD_RIGHTS_XXX flags that are described on the ACCESS_MASK reference page. You can also combine
		/// these bitmaps with additional flags from the preceding table. The following table shows how the bitmaps correspond to specific
		/// access rights.
		/// </para>
		/// <list type="table">
		/// <listheader>
		/// <term>Rights bitmap</term>
		/// <term>Set of specific access rights</term>
		/// </listheader>
		/// <item>
		/// <term>TRANSACTION_GENERIC_READ</term>
		/// <term>STANDARD_RIGHTS_READ, TRANSACTION_QUERY_INFORMATION, and SYNCHRONIZE</term>
		/// </item>
		/// <item>
		/// <term>TRANSACTION_GENERIC_WRITE</term>
		/// <term>
		/// STANDARD_RIGHTS_WRITE, TRANSACTION_SET_INFORMATION, TRANSACTION_COMMIT, TRANSACTION_ENLIST, TRANSACTION_ROLLBACK,
		/// TRANSACTION_PROPAGATE, TRANSACTION_SAVEPOINT, and SYNCHRONIZE
		/// </term>
		/// </item>
		/// <item>
		/// <term>TRANSACTION_GENERIC_EXECUTE</term>
		/// <term>STANDARD_RIGHTS_EXECUTE, TRANSACTION_COMMIT, TRANSACTION_ROLLBACK, and SYNCHRONIZE</term>
		/// </item>
		/// <item>
		/// <term>TRANSACTION_ALL_ACCESS</term>
		/// <term>STANDARD_RIGHTS_REQUIRED, TRANSACTION_GENERIC_READ, TRANSACTION_GENERIC_WRITE, and TRANSACTION_GENERIC_EXECUTE</term>
		/// </item>
		/// <item>
		/// <term>TRANSACTION_RESOURCE_MANAGER_RIGHTS</term>
		/// <term>
		/// STANDARD_RIGHTS_WRITE, TRANSACTION_GENERIC_READ, TRANSACTION_SET_INFORMATION, TRANSACTION_ENLIST, TRANSACTION_ROLLBACK,
		/// TRANSACTION_PROPAGATE, and SYNCHRONIZE
		/// </term>
		/// </item>
		/// </list>
		/// <para>Typically, a resource manager specifies TRANSACTION_RESOURCE_MANAGER_RIGHTS.</para>
		/// <para>The DesiredAccess value cannot be zero.</para>
		/// </param>
		/// <param name="ObjectAttributes">
		/// <para>
		/// A pointer to an OBJECT_ATTRIBUTES structure that specifies the object name and other attributes. Use the
		/// InitializeObjectAttributes routine to initialize this structure. If the caller is not running in a system thread context, it
		/// must set the OBJ_KERNEL_HANDLE attribute when it calls <c>InitializeObjectAttributes</c>. This parameter is optional and can be <c>NULL</c>.
		/// </para>
		/// </param>
		/// <param name="Uow">
		/// <para>
		/// A pointer to a GUID that KTM uses as the new transaction object's unit of work (UOW) identifier. This parameter is optional and
		/// can be <c>NULL</c>. If this parameter is <c>NULL</c>, KTM generates a GUID and assigns it to the transaction object. For more
		/// information, see the following Remarks section.
		/// </para>
		/// </param>
		/// <param name="TmHandle">
		/// <para>
		/// A handle to a transaction manager object that was obtained by a previous call to ZwCreateTransactionManager or
		/// ZwOpenTransactionManager. KTM assigns the new transaction object to the specified transaction manager object. If this parameter
		/// is <c>NULL</c>, KTM assigns the new transaction object to a transaction manager later, when a resource manager creates an
		/// enlistment for the transaction.
		/// </para>
		/// </param>
		/// <param name="CreateOptions">
		/// <para>Optional object creation flags. The following table contains the available flags, which are defined in Ktmtypes.h.</para>
		/// <list type="table">
		/// <listheader>
		/// <term>Option flag</term>
		/// <term>Meaning</term>
		/// </listheader>
		/// <item>
		/// <term>TRANSACTION_DO_NOT_PROMOTE</term>
		/// <term>Reserved for future use.</term>
		/// </item>
		/// </list>
		/// </param>
		/// <param name="IsolationLevel">
		/// <para>Reserved for future use. Callers must set this parameter to zero.</para>
		/// </param>
		/// <param name="IsolationFlags">
		/// <para>Reserved for future use. Callers should set this parameter to zero.</para>
		/// </param>
		/// <param name="Timeout">
		/// <para>
		/// A pointer to a time-out value. If the transaction has not been committed by the time specified by this parameter, KTM rolls back
		/// the transaction. The time-out value is expressed in system time units (100-nanosecond intervals), and can specify either an
		/// absolute time or a relative time. If the value pointed to by Timeout is negative, the expiration time is relative to the current
		/// system time. Otherwise, the expiration time is absolute. This pointer is optional and can be <c>NULL</c> if you do not want the
		/// transaction to have a time-out value. If Timeout = <c>NULL</c> or *Timeout = 0, the transaction never times out. (You can also
		/// use ZwSetInformationTransaction to set a time-out value.)
		/// </para>
		/// </param>
		/// <param name="Description">
		/// <para>
		/// A pointer to a caller-supplied UNICODE_STRING structure that contains a NULL-terminated string. The string provides a
		/// description of the transaction. KTM stores a copy of the string and includes the string in messages that it writes to the log
		/// stream. The maximum string length is MAX_TRANSACTION_DESCRIPTION_LENGTH. This parameter is optional and can be <c>NULL</c>.
		/// </para>
		/// </param>
		/// <returns>
		/// <para>
		/// <c>ZwCreateTransaction</c> returns STATUS_SUCCESS if the operation succeeds. Otherwise, this routine might return one of the
		/// following values:
		/// </para>
		/// <list type="table">
		/// <listheader>
		/// <term>Return code</term>
		/// <term>Description</term>
		/// </listheader>
		/// <item>
		/// <term>STATUS_INVALID_PARAMETER</term>
		/// <term>
		/// The CreateOptions parameter contains an invalid flag, the DesiredAccess parameter is zero, or the Description parameter's string
		/// is too long.
		/// </term>
		/// </item>
		/// <item>
		/// <term>STATUS_INSUFFICIENT_RESOURCES</term>
		/// <term>KTM could not allocate system resources (typically memory).</term>
		/// </item>
		/// <item>
		/// <term>STATUS_INVALID_ACL</term>
		/// <term>A security descriptor contains an invalid access control list (ACL).</term>
		/// </item>
		/// <item>
		/// <term>STATUS_INVALID_SID</term>
		/// <term>A security descriptor contains an invalid security identifier (SID).</term>
		/// </item>
		/// <item>
		/// <term>STATUS_OBJECT_NAME_EXISTS</term>
		/// <term>The object name that the ObjectAttributes parameter specifies already exists.</term>
		/// </item>
		/// <item>
		/// <term>STATUS_OBJECT_NAME_INVALID</term>
		/// <term>The object name that the ObjectAttributes parameter specifies is invalid.</term>
		/// </item>
		/// <item>
		/// <term>STATUS_ACCESS_DENIED</term>
		/// <term>The value of the DesiredAccess parameter is invalid.</term>
		/// </item>
		/// </list>
		/// <para>The routine might return other NTSTATUS values.</para>
		/// </returns>
		/// <remarks>
		/// <para>
		/// The caller can use the Uow parameter to specify a UOW identifier for the transaction object. If the caller does not specify a
		/// UOW identifier, KTM generates a GUID and assigns it to the transaction object. The caller can later obtain this GUID by calling ZwQueryInformationTransaction.
		/// </para>
		/// <para>
		/// Typically, you should let KTM generate a GUID for the transaction object, unless your component communicates with another TPS
		/// component that has already generated a UOW identifier for the transaction.
		/// </para>
		/// <para>
		/// To close the transaction handle, the component that called <c>ZwCreateTransaction</c> must call ZwClose. If the last transaction
		/// handle closes before any component calls ZwCommitTransaction for the transaction, KTM rolls back the transaction.
		/// </para>
		/// <para>
		/// For more information about how transaction clients should use <c>ZwCreateTransaction</c>, see Creating a Transactional Client.
		/// </para>
		/// <para>
		/// For calls from kernel-mode drivers, the <c>NtXxx</c> and <c>ZwXxx</c> versions of a Windows Native System Services routine can
		/// behave differently in the way that they handle and interpret input parameters. For more information about the relationship
		/// between the <c>NtXxx</c> and <c>ZwXxx</c> versions of a routine, see Using Nt and Zw Versions of the Native System Services Routines.
		/// </para>
		/// </remarks>
		// https://docs.microsoft.com/en-us/windows-hardware/drivers/ddi/content/wdm/nf-wdm-ntcreatetransaction __kernel_entry NTSYSCALLAPI
		// NTSTATUS NtCreateTransaction( PHANDLE TransactionHandle, ACCESS_MASK DesiredAccess, POBJECT_ATTRIBUTES ObjectAttributes, LPGUID
		// Uow, HANDLE TmHandle, ULONG CreateOptions, ULONG IsolationLevel, ULONG IsolationFlags, PLARGE_INTEGER Timeout, PUNICODE_STRING
		// Description );
		[DllImport(Lib.NtDll, SetLastError = false, CharSet = CharSet.Auto)]
		[PInvokeData("wdm.h", MSDNShortId = "b4c2dd68-3c1a-46d3-ab9c-be2291ed80f4")]
		public static extern NTStatus NtCreateTransaction(out SafeTransactionHandle TransactionHandle, ACCESS_MASK DesiredAccess, [In, Optional] IntPtr ObjectAttributes,
			[In, Optional] IntPtr Uow, [In, Optional] IntPtr TmHandle, [Optional] uint CreateOptions, [Optional] uint IsolationLevel,
			[Optional] uint IsolationFlags, [In, Optional] IntPtr Timeout, [In, Optional, MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UnicodeStringMarshaler))] string Description);

		/// <summary>
		/// <para>The <c>ZwCreateTransactionManager</c> routine creates a new transaction manager object.</para>
		/// </summary>
		/// <param name="TmHandle">
		/// <para>A pointer to a caller-allocated variable that receives a handle to the new transaction manager object.</para>
		/// </param>
		/// <param name="DesiredAccess">
		/// <para>
		/// An ACCESS_MASK value that specifies the caller's requested access to the transaction manager object. In addition to the access
		/// rights that are defined for all kinds of objects (see ACCESS_MASK), the caller can specify any of the following access right
		/// flags for transaction manager objects.
		/// </para>
		/// <list type="table">
		/// <listheader>
		/// <term>ACCESS_MASK flag</term>
		/// <term>Allows the caller to</term>
		/// </listheader>
		/// <item>
		/// <term>TRANSACTIONMANAGER_CREATE_RM</term>
		/// <term>Create a resource manager (see ZwCreateResourceManager).</term>
		/// </item>
		/// <item>
		/// <term>TRANSACTIONMANAGER_QUERY_INFORMATION</term>
		/// <term>
		/// Obtain information about the transaction manager (see ZwQueryInformationTransactionManager and ZwEnumerateTransactionObject).
		/// Also required for ZwOpenResourceManager, ZwCreateTransaction, and ZwOpenTransaction.)
		/// </term>
		/// </item>
		/// <item>
		/// <term>TRANSACTIONMANAGER_RECOVER</term>
		/// <term>Recover the transaction manager (see ZwRecoverTransactionManager and ZwRollforwardTransactionManager).</term>
		/// </item>
		/// <item>
		/// <term>TRANSACTIONMANAGER_RENAME</term>
		/// <term>Not used.</term>
		/// </item>
		/// <item>
		/// <term>TRANSACTIONMANAGER_SET_INFORMATION</term>
		/// <term>Not used.</term>
		/// </item>
		/// </list>
		/// <para>
		/// Alternatively, you can specify one or more of the following ACCESS_MASK bitmaps. These bitmaps combine the flags from the
		/// previous table with the STANDARD_RIGHTS_XXX flags that are described on the <c>ACCESS_MASK</c> reference page. You can also
		/// combine these bitmaps with additional flags from the preceding table. The following table shows how the bitmaps correspond to
		/// specific access rights.
		/// </para>
		/// <list type="table">
		/// <listheader>
		/// <term>Rights bitmap</term>
		/// <term>Set of specific access rights</term>
		/// </listheader>
		/// <item>
		/// <term>TRANSACTIONMANAGER_GENERIC_READ</term>
		/// <term>STANDARD_RIGHTS_READ and TRANSACTIONMANAGER_QUERY_INFORMATION</term>
		/// </item>
		/// <item>
		/// <term>TRANSACTIONMANAGER_GENERIC_WRITE</term>
		/// <term>
		/// STANDARD_RIGHTS_WRITE, TRANSACTIONMANAGER_SET_INFORMATION, TRANSACTIONMANAGER_RECOVER, TRANSACTIONMANAGER_RENAME, and TRANSACTIONMANAGER_CREATE_RM
		/// </term>
		/// </item>
		/// <item>
		/// <term>TRANSACTIONMANAGER_GENERIC_EXECUTE</term>
		/// <term>STANDARD_RIGHTS_EXECUTE</term>
		/// </item>
		/// <item>
		/// <term>TRANSACTIONMANAGER_ALL_ACCESS</term>
		/// <term>STANDARD_RIGHTS_REQUIRED, TRANSACTIONMANAGER_GENERIC_READ, TRANSACTIONMANAGER_GENERIC_WRITE, and TRANSACTIONMANAGER_GENERIC_EXECUTE</term>
		/// </item>
		/// </list>
		/// </param>
		/// <param name="ObjectAttributes">
		/// <para>
		/// A pointer to an OBJECT_ATTRIBUTES structure that specifies the object name and other attributes. Use the
		/// InitializeObjectAttributes routine to initialize this structure. If the caller is not running in a system thread context, it
		/// must set the OBJ_KERNEL_HANDLE attribute when it calls <c>InitializeObjectAttributes</c>. This parameter is optional and can be <c>NULL</c>.
		/// </para>
		/// </param>
		/// <param name="LogFileName">
		/// <para>
		/// A pointer to a UNICODE_STRING structure that contains the path and file name of a CLFS log file stream to be associated with the
		/// transaction manager object. This parameter must be <c>NULL</c> if the CreateOptions parameter is TRANSACTION_MANAGER_VOLATILE.
		/// Otherwise, this parameter must be non- <c>NULL</c>. For more information, see the following Remarks section.
		/// </para>
		/// </param>
		/// <param name="CreateOptions">
		/// <para>Optional object creation flags. The following table contains the available flags, which are defined in Ktmtypes.h.</para>
		/// <list type="table">
		/// <listheader>
		/// <term>Option flag</term>
		/// <term>Meaning</term>
		/// </listheader>
		/// <item>
		/// <term>TRANSACTION_MANAGER_VOLATILE</term>
		/// <term>The transaction manager object will be volatile. Therefore, it will not use a log file.</term>
		/// </item>
		/// <item>
		/// <term>TRANSACTION_MANAGER_COMMIT_DEFAULT</term>
		/// <term>For internal use only.</term>
		/// </item>
		/// <item>
		/// <term>TRANSACTION_MANAGER_COMMIT_SYSTEM_VOLUME</term>
		/// <term>For internal use only.</term>
		/// </item>
		/// <item>
		/// <term>TRANSACTION_MANAGER_COMMIT_SYSTEM_HIVES</term>
		/// <term>For internal use only.</term>
		/// </item>
		/// <item>
		/// <term>TRANSACTION_MANAGER_COMMIT_LOWEST</term>
		/// <term>For internal use only.</term>
		/// </item>
		/// <item>
		/// <term>TRANSACTION_MANAGER_CORRUPT_FOR_RECOVERY</term>
		/// <term>For internal use only.</term>
		/// </item>
		/// <item>
		/// <term>TRANSACTION_MANAGER_CORRUPT_FOR_PROGRESS</term>
		/// <term>For internal use only.</term>
		/// </item>
		/// </list>
		/// </param>
		/// <param name="CommitStrength">
		/// <para>Reserved for future use. This parameter must be zero.</para>
		/// </param>
		/// <returns>
		/// <para>
		/// <c>ZwCreateTransactionManager</c> returns STATUS_SUCCESS if the operation succeeds. Otherwise, this routine might return one of
		/// the following values:
		/// </para>
		/// <list type="table">
		/// <listheader>
		/// <term>Return code</term>
		/// <term>Description</term>
		/// </listheader>
		/// <item>
		/// <term>STATUS_INVALID_PARAMETER</term>
		/// <term>The value of an input parameter is invalid.</term>
		/// </item>
		/// <item>
		/// <term>STATUS_INSUFFICIENT_RESOURCES</term>
		/// <term>KTM could not allocate system resources (typically memory).</term>
		/// </item>
		/// <item>
		/// <term>STATUS_LOG_CORRUPTION_DETECTED</term>
		/// <term>KTM encountered an error while creating or opening the log file.</term>
		/// </item>
		/// <item>
		/// <term>STATUS_INVALID_ACL</term>
		/// <term>A security descriptor contains an invalid access control list (ACL).</term>
		/// </item>
		/// <item>
		/// <term>STATUS_INVALID_SID</term>
		/// <term>A security descriptor contains an invalid security identifier (SID).</term>
		/// </item>
		/// <item>
		/// <term>STATUS_OBJECT_NAME_EXISTS</term>
		/// <term>The object name that the ObjectAttributes parameter specifies already exists.</term>
		/// </item>
		/// <item>
		/// <term>STATUS_OBJECT_NAME_COLLISION</term>
		/// <term>The operating system detected a duplicate object name. The error might indicate that the log stream is already being used.</term>
		/// </item>
		/// <item>
		/// <term>STATUS_OBJECT_NAME_INVALID</term>
		/// <term>The object name that the ObjectAttributes parameter specifies is invalid.</term>
		/// </item>
		/// <item>
		/// <term>STATUS_ACCESS_DENIED</term>
		/// <term>The value of the DesiredAccess parameter is invalid.</term>
		/// </item>
		/// </list>
		/// <para>The routine might return other NTSTATUS values.</para>
		/// </returns>
		/// <remarks>
		/// <para>
		/// If the log file stream that the LogFileName parameter specifies does not exist, KTM calls CLFS to create the stream. If the
		/// stream already exists, KTM calls CLFS to open the stream.
		/// </para>
		/// <para>Your TPS component must call ZwRecoverTransactionManager after it has called <c>ZwCreateTransactionManager</c></para>
		/// <para>
		/// If your TPS component specifies the TRANSACTION_MANAGER_VOLATILE flag in the CreateOptions parameter, all resource managers that
		/// are associated with the transaction manager object must specify the RESOURCE_MANAGER_VOLATILE flag when they call ZwCreateResourceManager.
		/// </para>
		/// <para>A TPS component that calls <c>ZwCreateTransactionManager</c> must eventually call ZwClose to close the object handle.</para>
		/// <para>For more information about how use <c>ZwCreateTransactionManager</c>, see Creating a Resource Manager.</para>
		/// <para>
		/// <c>NtCreateTransactionManager</c> and <c>ZwCreateTransactionManager</c> are two versions of the same Windows Native System
		/// Services routine.
		/// </para>
		/// <para>
		/// For calls from kernel-mode drivers, the <c>NtXxx</c> and <c>ZwXxx</c> versions of a Windows Native System Services routine can
		/// behave differently in the way that they handle and interpret input parameters. For more information about the relationship
		/// between the <c>NtXxx</c> and <c>ZwXxx</c> versions of a routine, see Using Nt and Zw Versions of the Native System Services Routines.
		/// </para>
		/// </remarks>
		// https://docs.microsoft.com/en-us/windows-hardware/drivers/ddi/content/wdm/nf-wdm-ntcreatetransactionmanager __kernel_entry
		// NTSYSCALLAPI NTSTATUS NtCreateTransactionManager( PHANDLE TmHandle, ACCESS_MASK DesiredAccess, POBJECT_ATTRIBUTES
		// ObjectAttributes, PUNICODE_STRING LogFileName, ULONG CreateOptions, ULONG CommitStrength );
		[DllImport(Lib.NtDll, SetLastError = false, CharSet = CharSet.Auto)]
		[PInvokeData("wdm.h", MSDNShortId = "9c9f0a8b-7add-4ab1-835d-39f508ce32a9")]
		public static extern NTStatus NtCreateTransactionManager(out SafeTransactionManagerHandle TmHandle, ACCESS_MASK DesiredAccess, in OBJECT_ATTRIBUTES ObjectAttributes,
			[In, Optional, MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UnicodeStringMarshaler))] string LogFileName, [Optional] uint CreateOptions, [Optional] uint CommitStrength);

		/// <summary>
		/// <para>The <c>ZwCreateTransactionManager</c> routine creates a new transaction manager object.</para>
		/// </summary>
		/// <param name="TmHandle">
		/// <para>A pointer to a caller-allocated variable that receives a handle to the new transaction manager object.</para>
		/// </param>
		/// <param name="DesiredAccess">
		/// <para>
		/// An ACCESS_MASK value that specifies the caller's requested access to the transaction manager object. In addition to the access
		/// rights that are defined for all kinds of objects (see ACCESS_MASK), the caller can specify any of the following access right
		/// flags for transaction manager objects.
		/// </para>
		/// <list type="table">
		/// <listheader>
		/// <term>ACCESS_MASK flag</term>
		/// <term>Allows the caller to</term>
		/// </listheader>
		/// <item>
		/// <term>TRANSACTIONMANAGER_CREATE_RM</term>
		/// <term>Create a resource manager (see ZwCreateResourceManager).</term>
		/// </item>
		/// <item>
		/// <term>TRANSACTIONMANAGER_QUERY_INFORMATION</term>
		/// <term>
		/// Obtain information about the transaction manager (see ZwQueryInformationTransactionManager and ZwEnumerateTransactionObject).
		/// Also required for ZwOpenResourceManager, ZwCreateTransaction, and ZwOpenTransaction.)
		/// </term>
		/// </item>
		/// <item>
		/// <term>TRANSACTIONMANAGER_RECOVER</term>
		/// <term>Recover the transaction manager (see ZwRecoverTransactionManager and ZwRollforwardTransactionManager).</term>
		/// </item>
		/// <item>
		/// <term>TRANSACTIONMANAGER_RENAME</term>
		/// <term>Not used.</term>
		/// </item>
		/// <item>
		/// <term>TRANSACTIONMANAGER_SET_INFORMATION</term>
		/// <term>Not used.</term>
		/// </item>
		/// </list>
		/// <para>
		/// Alternatively, you can specify one or more of the following ACCESS_MASK bitmaps. These bitmaps combine the flags from the
		/// previous table with the STANDARD_RIGHTS_XXX flags that are described on the <c>ACCESS_MASK</c> reference page. You can also
		/// combine these bitmaps with additional flags from the preceding table. The following table shows how the bitmaps correspond to
		/// specific access rights.
		/// </para>
		/// <list type="table">
		/// <listheader>
		/// <term>Rights bitmap</term>
		/// <term>Set of specific access rights</term>
		/// </listheader>
		/// <item>
		/// <term>TRANSACTIONMANAGER_GENERIC_READ</term>
		/// <term>STANDARD_RIGHTS_READ and TRANSACTIONMANAGER_QUERY_INFORMATION</term>
		/// </item>
		/// <item>
		/// <term>TRANSACTIONMANAGER_GENERIC_WRITE</term>
		/// <term>
		/// STANDARD_RIGHTS_WRITE, TRANSACTIONMANAGER_SET_INFORMATION, TRANSACTIONMANAGER_RECOVER, TRANSACTIONMANAGER_RENAME, and TRANSACTIONMANAGER_CREATE_RM
		/// </term>
		/// </item>
		/// <item>
		/// <term>TRANSACTIONMANAGER_GENERIC_EXECUTE</term>
		/// <term>STANDARD_RIGHTS_EXECUTE</term>
		/// </item>
		/// <item>
		/// <term>TRANSACTIONMANAGER_ALL_ACCESS</term>
		/// <term>STANDARD_RIGHTS_REQUIRED, TRANSACTIONMANAGER_GENERIC_READ, TRANSACTIONMANAGER_GENERIC_WRITE, and TRANSACTIONMANAGER_GENERIC_EXECUTE</term>
		/// </item>
		/// </list>
		/// </param>
		/// <param name="ObjectAttributes">
		/// <para>
		/// A pointer to an OBJECT_ATTRIBUTES structure that specifies the object name and other attributes. Use the
		/// InitializeObjectAttributes routine to initialize this structure. If the caller is not running in a system thread context, it
		/// must set the OBJ_KERNEL_HANDLE attribute when it calls <c>InitializeObjectAttributes</c>. This parameter is optional and can be <c>NULL</c>.
		/// </para>
		/// </param>
		/// <param name="LogFileName">
		/// <para>
		/// A pointer to a UNICODE_STRING structure that contains the path and file name of a CLFS log file stream to be associated with the
		/// transaction manager object. This parameter must be <c>NULL</c> if the CreateOptions parameter is TRANSACTION_MANAGER_VOLATILE.
		/// Otherwise, this parameter must be non- <c>NULL</c>. For more information, see the following Remarks section.
		/// </para>
		/// </param>
		/// <param name="CreateOptions">
		/// <para>Optional object creation flags. The following table contains the available flags, which are defined in Ktmtypes.h.</para>
		/// <list type="table">
		/// <listheader>
		/// <term>Option flag</term>
		/// <term>Meaning</term>
		/// </listheader>
		/// <item>
		/// <term>TRANSACTION_MANAGER_VOLATILE</term>
		/// <term>The transaction manager object will be volatile. Therefore, it will not use a log file.</term>
		/// </item>
		/// <item>
		/// <term>TRANSACTION_MANAGER_COMMIT_DEFAULT</term>
		/// <term>For internal use only.</term>
		/// </item>
		/// <item>
		/// <term>TRANSACTION_MANAGER_COMMIT_SYSTEM_VOLUME</term>
		/// <term>For internal use only.</term>
		/// </item>
		/// <item>
		/// <term>TRANSACTION_MANAGER_COMMIT_SYSTEM_HIVES</term>
		/// <term>For internal use only.</term>
		/// </item>
		/// <item>
		/// <term>TRANSACTION_MANAGER_COMMIT_LOWEST</term>
		/// <term>For internal use only.</term>
		/// </item>
		/// <item>
		/// <term>TRANSACTION_MANAGER_CORRUPT_FOR_RECOVERY</term>
		/// <term>For internal use only.</term>
		/// </item>
		/// <item>
		/// <term>TRANSACTION_MANAGER_CORRUPT_FOR_PROGRESS</term>
		/// <term>For internal use only.</term>
		/// </item>
		/// </list>
		/// </param>
		/// <param name="CommitStrength">
		/// <para>Reserved for future use. This parameter must be zero.</para>
		/// </param>
		/// <returns>
		/// <para>
		/// <c>ZwCreateTransactionManager</c> returns STATUS_SUCCESS if the operation succeeds. Otherwise, this routine might return one of
		/// the following values:
		/// </para>
		/// <list type="table">
		/// <listheader>
		/// <term>Return code</term>
		/// <term>Description</term>
		/// </listheader>
		/// <item>
		/// <term>STATUS_INVALID_PARAMETER</term>
		/// <term>The value of an input parameter is invalid.</term>
		/// </item>
		/// <item>
		/// <term>STATUS_INSUFFICIENT_RESOURCES</term>
		/// <term>KTM could not allocate system resources (typically memory).</term>
		/// </item>
		/// <item>
		/// <term>STATUS_LOG_CORRUPTION_DETECTED</term>
		/// <term>KTM encountered an error while creating or opening the log file.</term>
		/// </item>
		/// <item>
		/// <term>STATUS_INVALID_ACL</term>
		/// <term>A security descriptor contains an invalid access control list (ACL).</term>
		/// </item>
		/// <item>
		/// <term>STATUS_INVALID_SID</term>
		/// <term>A security descriptor contains an invalid security identifier (SID).</term>
		/// </item>
		/// <item>
		/// <term>STATUS_OBJECT_NAME_EXISTS</term>
		/// <term>The object name that the ObjectAttributes parameter specifies already exists.</term>
		/// </item>
		/// <item>
		/// <term>STATUS_OBJECT_NAME_COLLISION</term>
		/// <term>The operating system detected a duplicate object name. The error might indicate that the log stream is already being used.</term>
		/// </item>
		/// <item>
		/// <term>STATUS_OBJECT_NAME_INVALID</term>
		/// <term>The object name that the ObjectAttributes parameter specifies is invalid.</term>
		/// </item>
		/// <item>
		/// <term>STATUS_ACCESS_DENIED</term>
		/// <term>The value of the DesiredAccess parameter is invalid.</term>
		/// </item>
		/// </list>
		/// <para>The routine might return other NTSTATUS values.</para>
		/// </returns>
		/// <remarks>
		/// <para>
		/// If the log file stream that the LogFileName parameter specifies does not exist, KTM calls CLFS to create the stream. If the
		/// stream already exists, KTM calls CLFS to open the stream.
		/// </para>
		/// <para>Your TPS component must call ZwRecoverTransactionManager after it has called <c>ZwCreateTransactionManager</c></para>
		/// <para>
		/// If your TPS component specifies the TRANSACTION_MANAGER_VOLATILE flag in the CreateOptions parameter, all resource managers that
		/// are associated with the transaction manager object must specify the RESOURCE_MANAGER_VOLATILE flag when they call ZwCreateResourceManager.
		/// </para>
		/// <para>A TPS component that calls <c>ZwCreateTransactionManager</c> must eventually call ZwClose to close the object handle.</para>
		/// <para>For more information about how use <c>ZwCreateTransactionManager</c>, see Creating a Resource Manager.</para>
		/// <para>
		/// <c>NtCreateTransactionManager</c> and <c>ZwCreateTransactionManager</c> are two versions of the same Windows Native System
		/// Services routine.
		/// </para>
		/// <para>
		/// For calls from kernel-mode drivers, the <c>NtXxx</c> and <c>ZwXxx</c> versions of a Windows Native System Services routine can
		/// behave differently in the way that they handle and interpret input parameters. For more information about the relationship
		/// between the <c>NtXxx</c> and <c>ZwXxx</c> versions of a routine, see Using Nt and Zw Versions of the Native System Services Routines.
		/// </para>
		/// </remarks>
		// https://docs.microsoft.com/en-us/windows-hardware/drivers/ddi/content/wdm/nf-wdm-ntcreatetransactionmanager __kernel_entry
		// NTSYSCALLAPI NTSTATUS NtCreateTransactionManager( PHANDLE TmHandle, ACCESS_MASK DesiredAccess, POBJECT_ATTRIBUTES
		// ObjectAttributes, PUNICODE_STRING LogFileName, ULONG CreateOptions, ULONG CommitStrength );
		[DllImport(Lib.NtDll, SetLastError = false, CharSet = CharSet.Auto)]
		[PInvokeData("wdm.h", MSDNShortId = "9c9f0a8b-7add-4ab1-835d-39f508ce32a9")]
		public static extern NTStatus NtCreateTransactionManager(out SafeTransactionManagerHandle TmHandle, ACCESS_MASK DesiredAccess, [In, Optional] IntPtr ObjectAttributes,
			[In, Optional, MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UnicodeStringMarshaler))] string LogFileName, [Optional] uint CreateOptions, [Optional] uint CommitStrength);

		/// <summary>
		/// <para>
		/// The <c>ZwQueryKey</c> routine provides information about the class of a registry key, and the number and sizes of its subkeys.
		/// </para>
		/// </summary>
		/// <param name="KeyHandle">
		/// <para>
		/// Handle to the registry key to obtain information about. This handle is created by a successful call to ZwCreateKey or ZwOpenKey.
		/// </para>
		/// </param>
		/// <param name="KeyInformationClass">
		/// <para>Specifies a KEY_INFORMATION_CLASS value that determines the type of information returned in the KeyInformation buffer.</para>
		/// </param>
		/// <param name="KeyInformation">
		/// <para>Pointer to a caller-allocated buffer that receives the requested information.</para>
		/// </param>
		/// <param name="Length">
		/// <para>Specifies the size, in bytes, of the KeyInformation buffer.</para>
		/// </param>
		/// <param name="ResultLength">
		/// <para>
		/// Pointer to a variable that receives the size, in bytes, of the requested key information. If <c>ZwQueryKey</c> returns
		/// STATUS_SUCCESS, the variable contains the amount of data returned. If <c>ZwQueryKey</c> returns STATUS_BUFFER_OVERFLOW or
		/// STATUS_BUFFER_TOO_SMALL, you can use the value of the variable to determine the required buffer size.
		/// </para>
		/// </param>
		/// <returns>
		/// <para>
		/// <c>ZwQueryKey</c> returns STATUS_SUCCESS on success, or the appropriate error code on failure. Possible error code values include:
		/// </para>
		/// <list type="table">
		/// <listheader>
		/// <term>Return code</term>
		/// <term>Description</term>
		/// </listheader>
		/// <item>
		/// <term>STATUS_BUFFER_OVERFLOW</term>
		/// <term>
		/// The buffer supplied is too small, and only partial data has been written to the buffer. *ResultLength is set to the minimum size
		/// required to hold the requested information.
		/// </term>
		/// </item>
		/// <item>
		/// <term>STATUS_BUFFER_TOO_SMALL</term>
		/// <term>
		/// The buffer supplied is too small, and no data has been written to the buffer. *ResultLength is set to the minimum size required
		/// to hold the requested information.
		/// </term>
		/// </item>
		/// <item>
		/// <term>STATUS_INVALID_PARAMETER</term>
		/// <term>The KeyInformationClass parameter is not a valid KEY_INFORMATION_CLASS value.</term>
		/// </item>
		/// </list>
		/// </returns>
		/// <remarks>
		/// <para>
		/// The KeyHandle passed to <c>ZwQueryKey</c> must have been opened with KEY_QUERY_VALUE access. This is accomplished by passing
		/// KEY_QUERY_VALUE, KEY_READ, or KEY_ALL_ACCESS as the DesiredAccess parameter to ZwCreateKey or ZwOpenKey.
		/// </para>
		/// <para>
		/// <c>ZwQueryKey</c> can be used to obtain information that you can use to allocate buffers to hold registry data, such as the
		/// maximum size of a key's value entries or subkey names, or the number of subkeys. For example, you can call <c>ZwQueryKey</c>,
		/// use the returned information to allocate a buffer for a subkey, call ZwEnumerateKey to get the name of the subkey, and pass that
		/// name to an <c>Rtl</c><c>Xxx</c><c>Registry</c> routine.
		/// </para>
		/// <para>For more information about working with registry keys, see Using the Registry in a Driver.</para>
		/// <para>
		/// For calls from kernel-mode drivers, the <c>NtXxx</c> and <c>ZwXxx</c> versions of a Windows Native System Services routine can
		/// behave differently in the way that they handle and interpret input parameters. For more information about the relationship
		/// between the <c>NtXxx</c> and <c>ZwXxx</c> versions of a routine, see Using Nt and Zw Versions of the Native System Services Routines.
		/// </para>
		/// </remarks>
		// https://docs.microsoft.com/en-us/windows-hardware/drivers/ddi/content/wdm/nf-wdm-zwquerykey NTSYSAPI NTSTATUS ZwQueryKey( HANDLE
		// KeyHandle, KEY_INFORMATION_CLASS KeyInformationClass, PVOID KeyInformation, ULONG Length, PULONG ResultLength );
		[DllImport(Lib.NtDll, SetLastError = false, ExactSpelling = true, CharSet = CharSet.Unicode)]
		[PInvokeData("wdm.h", MSDNShortId = "3b2d3a8b-a21f-4067-a1f0-9aa66c1973f5")]
		// public static extern NTSYSAPI NTSTATUS ZwQueryKey(IntPtr KeyHandle, KEY_INFORMATION_CLASS KeyInformationClass, IntPtr
		// KeyInformation, uint Length, ref uint ResultLength);
		public static extern NTStatus NtQueryKey(HKEY KeyHandle, KEY_INFORMATION_CLASS KeyInformationClass, [Out] SafeHGlobalHandle KeyInformation, uint Length, out uint ResultLength);

		/// <summary>Gets version information about the currently running operating system.</summary>
		/// <param name="lpVersionInformation">
		/// Pointer to either a <c>RTL_OSVERSIONINFOW</c> structure or a <c>RTL_OSVERSIONINFOEXW</c> structure that contains the version
		/// information about the currently running operating system. A caller specifies which input structure is used by setting the
		/// <c>dwOSVersionInfoSize</c> member of the structure to the size in bytes of the structure that is used.
		/// </param>
		/// <returns>Returns STATUS_SUCCESS.</returns>
		/// <remarks>
		/// <para>
		/// <c>RtlGetVersion</c> is the equivalent of the <c>GetVersionEx</c> function in the Windows SDK. See the example in the Windows SDK
		/// that shows how to get the system version.
		/// </para>
		/// <para>
		/// When using <c>RtlGetVersion</c> to determine whether a particular version of the operating system is running, a caller should check
		/// for version numbers that are greater than or equal to the required version number. This ensures that a version test succeeds for
		/// later versions of Windows.
		/// </para>
		/// <para>
		/// Because operating system features can be added in a redistributable DLL, checking only the major and minor version numbers is not the
		/// most reliable way to verify the presence of a specific system feature. A driver should use <c>RtlVerifyVersionInfo</c> to test for
		/// the presence of a specific system feature.
		/// </para>
		/// </remarks>
		// https://learn.microsoft.com/en-us/windows/win32/devnotes/rtlgetversion
		// NTSTATUS RtlGetVersion( _Out_&#194; PRTL_OSVERSIONINFOW lpVersionInformation );
		[PInvokeData("Ntddk.h")]
		[DllImport(Lib.NtDll, SetLastError = false, ExactSpelling = true)]
		public static extern NTStatus RtlGetVersion(out OSVERSIONINFOW lpVersionInformation);       
		
		/// <summary>
																									/// <para>
																									/// A driver sets an IRP's I/O status block to indicate the final status of an I/O request, before calling IoCompleteRequest for the IRP.
																									/// </para>
																									/// </summary>
																									/// <remarks>
																									/// <para>
																									/// Unless a driver's dispatch routine completes an IRP with an error status value, the lowest-level driver in the chain frequently
																									/// sets the IRP's I/O status block to the values that will be returned to the original requester of the I/O operation.
																									/// </para>
																									/// <para>
																									/// The IoCompletion routines of higher-level drivers usually check the I/O status block in IRPs completed by lower drivers. By
																									/// design, the I/O status block in an IRP is the only information passed back from the underlying device driver to all higher-level
																									/// drivers' IoCompletion routines.
																									/// </para>
																									/// <para>
																									/// The operating system implements support routines that write <c>IO_STATUS_BLOCK</c> values to caller-supplied output buffers. For
																									/// example, see ZwOpenFile or NtOpenFile. These routines return status codes that might not match the status codes in the
																									/// <c>IO_STATUS_BLOCK</c> structures. If one of these routines returns STATUS_PENDING, the caller should wait for the I/O operation
																									/// to complete, and then check the status code in the <c>IO_STATUS_BLOCK</c> structure to determine the final status of the
																									/// operation. If the routine returns a status code other than STATUS_PENDING, the caller should rely on this status code instead of
																									/// the status code in the <c>IO_STATUS_BLOCK</c> structure.
																									/// </para>
																									/// <para>For more information, see I/O Status Blocks.</para>
																									/// </remarks>
		// https://docs.microsoft.com/en-us/windows-hardware/drivers/ddi/content/wdm/ns-wdm-_io_status_block typedef struct _IO_STATUS_BLOCK
		// { union { NTSTATUS Status; PVOID Pointer; } DUMMYUNIONNAME; ULONG_PTR Information; } IO_STATUS_BLOCK, *PIO_STATUS_BLOCK;
		[PInvokeData("wdm.h", MSDNShortId = "1ce2b1d0-a8b2-4a05-8895-e13802690a7b")]
		[StructLayout(LayoutKind.Sequential)]
		public struct IO_STATUS_BLOCK
		{
			/// <summary>
			/// This is the completion status, either STATUS_SUCCESS if the requested operation was completed successfully or an
			/// informational, warning, or error STATUS_XXX value. For more information, see Using NTSTATUS values.
			/// </summary>
			public uint Status;

			/// <summary>
			/// This is set to a request-dependent value. For example, on successful completion of a transfer request, this is set to the
			/// number of bytes transferred. If a transfer request is completed with another STATUS_XXX, this member is set to zero.
			/// </summary>
			public IntPtr Information;
		}

		/// <summary>
		/// <para>The <c>KEY_BASIC_INFORMATION</c> structure defines a subset of the full information that is available for a registry key.</para>
		/// </summary>
		/// <remarks>
		/// <para>
		/// The ZwEnumerateKey and ZwQueryKey routines use the <c>KEY_BASIC_INFORMATION</c> structure to contain the basic information for a
		/// registry key. When the KeyInformationClass parameter of either routine is <c>KeyBasicInformation</c>, the KeyInformation buffer
		/// is treated as a <c>KEY_BASIC_INFORMATION</c> structure. For more information about the <c>KeyBasicInformation</c> enumeration
		/// value, see KEY_INFORMATION_CLASS.
		/// </para>
		/// </remarks>
		// https://docs.microsoft.com/en-us/windows-hardware/drivers/ddi/content/wdm/ns-wdm-_key_basic_information typedef struct
		// _KEY_BASIC_INFORMATION { LARGE_INTEGER LastWriteTime; ULONG TitleIndex; ULONG NameLength; WCHAR Name[1]; } KEY_BASIC_INFORMATION, *PKEY_BASIC_INFORMATION;
		[PInvokeData("wdm.h", MSDNShortId = "789c60b6-a5a4-4570-bb0c-acfe1166a302")]
		[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
		public struct KEY_BASIC_INFORMATION
		{
			/// <summary>
			/// <para>
			/// The last time this key or any of its values changed. This time value is expressed in absolute system time format. Absolute
			/// system time is the number of 100-nanosecond intervals since the start of the year 1601 in the Gregorian calendar.
			/// </para>
			/// </summary>
			public long LastWriteTime;

			/// <summary>
			/// <para>Device and intermediate drivers should ignore this member.</para>
			/// </summary>
			public uint TitleIndex;

			/// <summary>
			/// <para>The size, in bytes, of the key name string in the <c>Name</c> array.</para>
			/// </summary>
			public uint NameLength;

			/// <summary>
			/// <para>
			/// An array of wide characters that contains the name of the registry key. This character string is null-terminated. Only the
			/// first element in this array is included in the <c>KEY_BASIC_INFORMATION</c> structure definition. The storage for the
			/// remaining elements in the array immediately follows this element.
			/// </para>
			/// </summary>
			public StrPtrUni Name;
		}

		/// <summary>
		/// <para>
		/// The <c>KEY_FULL_INFORMATION</c> structure defines the information available for a registry key, including information about its
		/// subkeys and the maximum length for their names and value entries. This information can be used to size buffers to get the names
		/// of subkeys and their value entries.
		/// </para>
		/// </summary>
		/// <remarks>
		/// <para>
		/// The ZwEnumerateKey and ZwQueryKey routines use the <c>KEY_FULL_INFORMATION</c> structure to contain the full information for a
		/// registry key. When the KeyInformationClass parameter of either routine is <c>KeyFullInformation</c>, the KeyInformation buffer
		/// is treated as a <c>KEY_FULL_INFORMATION</c> structure. For more information about the <c>KeyFullInformation</c> enumeration
		/// value, see KEY_INFORMATION_CLASS.
		/// </para>
		/// </remarks>
		// https://docs.microsoft.com/en-us/windows-hardware/drivers/ddi/content/wdm/ns-wdm-_key_full_information typedef struct
		// _KEY_FULL_INFORMATION { LARGE_INTEGER LastWriteTime; ULONG TitleIndex; ULONG ClassOffset; ULONG ClassLength; ULONG SubKeys; ULONG
		// MaxNameLen; ULONG MaxClassLen; ULONG Values; ULONG MaxValueNameLen; ULONG MaxValueDataLen; WCHAR Class[1]; }
		// KEY_FULL_INFORMATION, *PKEY_FULL_INFORMATION;
		[PInvokeData("wdm.h", MSDNShortId = "dd099435-e3e3-4d78-a829-0f12f2db46d9")]
		[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
		public struct KEY_FULL_INFORMATION
		{
			/// <summary>
			/// <para>
			/// The last time this key or any of its values changed. This time value is expressed in absolute system time format. Absolute
			/// system time is the number of 100-nanosecond intervals since the start of the year 1601 in the Gregorian calendar.
			/// </para>
			/// </summary>
			public long LastWriteTime;

			/// <summary>
			/// <para>Device and intermediate drivers should ignore this member.</para>
			/// </summary>
			public uint TitleIndex;

			/// <summary>
			/// <para>The byte offset from the start of this structure to the <c>Class</c> member.</para>
			/// </summary>
			public uint ClassOffset;

			/// <summary>
			/// <para>The size, in bytes, of the key class name string in the <c>Class</c> array.</para>
			/// </summary>
			public uint ClassLength;

			/// <summary>
			/// <para>The number of subkeys for this key.</para>
			/// </summary>
			public uint SubKeys;

			/// <summary>
			/// <para>The maximum size, in bytes, of any name for a subkey.</para>
			/// </summary>
			public uint MaxNameLen;

			/// <summary>
			/// <para>The maximum size, in bytes, of a class name.</para>
			/// </summary>
			public uint MaxClassLen;

			/// <summary>
			/// <para>The number of value entries for this key.</para>
			/// </summary>
			public uint Values;

			/// <summary>
			/// <para>The maximum size, in bytes, of a value entry name.</para>
			/// </summary>
			public uint MaxValueNameLen;

			/// <summary>
			/// <para>The maximum size, in bytes, of a value entry data field.</para>
			/// </summary>
			public uint MaxValueDataLen;

			/// <summary>
			/// <para>
			/// An array of wide characters that contains the name of the class of the key. This character string is null-terminated. Only
			/// the first element in this array is included in the <c>KEY_FULL_INFORMATION</c> structure definition. The storage for the
			/// remaining elements in the array immediately follows this element.
			/// </para>
			/// </summary>
			public StrPtrUni Class;
		}

		/// <summary>
		/// <para>The <c>KEY_NODE_INFORMATION</c> structure defines the basic information available for a registry (sub)key.</para>
		/// </summary>
		/// <remarks>
		/// <para>
		/// The ZwEnumerateKey and ZwQueryKey routines use the <c>KEY_NODE_INFORMATION</c> structure to contain the registry key name and
		/// key class name. When the KeyInformationClass parameter of either routine is <c>KeyNodeInformation</c>, the KeyInformation buffer
		/// is treated as a <c>KEY_NODE_INFORMATION</c> structure. For more information about the <c>KeyNodeInformation</c> enumeration
		/// value, see KEY_INFORMATION_CLASS.
		/// </para>
		/// </remarks>
		// https://docs.microsoft.com/en-us/windows-hardware/drivers/ddi/content/wdm/ns-wdm-_key_node_information typedef struct
		// _KEY_NODE_INFORMATION { LARGE_INTEGER LastWriteTime; ULONG TitleIndex; ULONG ClassOffset; ULONG ClassLength; ULONG NameLength;
		// WCHAR Name[1]; } KEY_NODE_INFORMATION, *PKEY_NODE_INFORMATION;
		[PInvokeData("wdm.h", MSDNShortId = "2eed1a3d-fc40-4416-ad61-d82bf4fb69a1")]
		[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
		public struct KEY_NODE_INFORMATION
		{
			/// <summary>
			/// <para>
			/// The last time this key or any of its values changed. This time value is expressed in absolute system time format. Absolute
			/// system time is the number of 100-nanosecond intervals since the start of the year 1601 in the Gregorian calendar.
			/// </para>
			/// </summary>
			public long LastWriteTime;

			/// <summary>
			/// <para>Device and intermediate drivers should ignore this member.</para>
			/// </summary>
			public uint TitleIndex;

			/// <summary>
			/// <para>
			/// The byte offset from the start of this structure to the class name string, which is located in the <c>Name</c> array
			/// immediately following the key name string. Like the key name string, the class name string is not null-terminated.
			/// </para>
			/// </summary>
			public uint ClassOffset;

			/// <summary>
			/// <para>The size, in bytes, in the class name string.</para>
			/// </summary>
			public uint ClassLength;

			/// <summary>
			/// <para>The size, in bytes, of the key name string contained in the <c>Name</c> array.</para>
			/// </summary>
			public uint NameLength;

			/// <summary>
			/// <para>
			/// An array of wide characters that contains the name of the registry key. This character string is null-terminated. Only the
			/// first element in this array is included in the <c>KEY_NODE_INFORMATION</c> structure definition. The storage for the
			/// remaining elements in the array immediately follows this element.
			/// </para>
			/// </summary>
			public StrPtrUni Name;
		}

		/// <summary>
		/// <para>
		/// Contains operating system version information. The information includes major and minor version numbers, a build number, a platform
		/// identifier, and descriptive text about the operating system. This structure is used with the GetVersionEx function.
		/// </para>
		/// <para>To obtain additional version information, use the OSVERSIONINFOEX structure with GetVersionEx instead.</para>
		/// </summary>
		/// <remarks>
		/// <para>
		/// Relying on version information is not the best way to test for a feature. Instead, refer to the documentation for the feature of
		/// interest. For more information on common techniques for feature detection, see Operating System Version.
		/// </para>
		/// <para>
		/// If you must require a particular operating system, be sure to use it as a minimum supported version, rather than design the test for
		/// the one operating system. This way, your detection code will continue to work on future versions of Windows.
		/// </para>
		/// <para>
		/// The following table summarizes the values returned by supported versions of Windows. Use the information in the column labeled
		/// "Other" to distinguish between operating systems with identical version numbers.
		/// </para>
		/// <list type="table">
		/// <listheader>
		/// <description>Operating system</description>
		/// <description>Version number</description>
		/// <description><c>dwMajorVersion</c></description>
		/// <description><c>dwMinorVersion</c></description>
		/// <description>Other</description>
		/// </listheader>
		/// <item>
		/// <description>WindowsÂ 10</description>
		/// <description>10.0*</description>
		/// <description>10</description>
		/// <description>0</description>
		/// <description>OSVERSIONINFOEX.wProductType == VER_NT_WORKSTATION</description>
		/// </item>
		/// <item>
		/// <description>Windows ServerÂ 2016</description>
		/// <description>10.0*</description>
		/// <description>10</description>
		/// <description>0</description>
		/// <description>OSVERSIONINFOEX.wProductType != VER_NT_WORKSTATION</description>
		/// </item>
		/// <item>
		/// <description>WindowsÂ 8.1</description>
		/// <description>6.3*</description>
		/// <description>6</description>
		/// <description>3</description>
		/// <description>OSVERSIONINFOEX.wProductType == VER_NT_WORKSTATION</description>
		/// </item>
		/// <item>
		/// <description>Windows ServerÂ 2012Â R2</description>
		/// <description>6.3*</description>
		/// <description>6</description>
		/// <description>3</description>
		/// <description>OSVERSIONINFOEX.wProductType != VER_NT_WORKSTATION</description>
		/// </item>
		/// <item>
		/// <description>WindowsÂ 8</description>
		/// <description>6.2</description>
		/// <description>6</description>
		/// <description>2</description>
		/// <description>OSVERSIONINFOEX.wProductType == VER_NT_WORKSTATION</description>
		/// </item>
		/// <item>
		/// <description>Windows ServerÂ 2012</description>
		/// <description>6.2</description>
		/// <description>6</description>
		/// <description>2</description>
		/// <description>OSVERSIONINFOEX.wProductType != VER_NT_WORKSTATION</description>
		/// </item>
		/// <item>
		/// <description>WindowsÂ 7</description>
		/// <description>6.1</description>
		/// <description>6</description>
		/// <description>1</description>
		/// <description>OSVERSIONINFOEX.wProductType == VER_NT_WORKSTATION</description>
		/// </item>
		/// <item>
		/// <description>Windows ServerÂ 2008Â R2</description>
		/// <description>6.1</description>
		/// <description>6</description>
		/// <description>1</description>
		/// <description>OSVERSIONINFOEX.wProductType != VER_NT_WORKSTATION</description>
		/// </item>
		/// <item>
		/// <description>Windows ServerÂ 2008</description>
		/// <description>6.0</description>
		/// <description>6</description>
		/// <description>0</description>
		/// <description>OSVERSIONINFOEX.wProductType != VER_NT_WORKSTATION</description>
		/// </item>
		/// <item>
		/// <description>WindowsÂ Vista</description>
		/// <description>6.0</description>
		/// <description>6</description>
		/// <description>0</description>
		/// <description>OSVERSIONINFOEX.wProductType == VER_NT_WORKSTATION</description>
		/// </item>
		/// <item>
		/// <description>Windows ServerÂ 2003Â R2</description>
		/// <description>5.2</description>
		/// <description>5</description>
		/// <description>2</description>
		/// <description>GetSystemMetrics(SM_SERVERR2) != 0</description>
		/// </item>
		/// <item>
		/// <description>Windows ServerÂ 2003</description>
		/// <description>5.2</description>
		/// <description>5</description>
		/// <description>2</description>
		/// <description>GetSystemMetrics(SM_SERVERR2) == 0</description>
		/// </item>
		/// <item>
		/// <description>WindowsÂ XP</description>
		/// <description>5.1</description>
		/// <description>5</description>
		/// <description>1</description>
		/// <description>Not applicable</description>
		/// </item>
		/// <item>
		/// <description>WindowsÂ 2000</description>
		/// <description>5.0</description>
		/// <description>5</description>
		/// <description>0</description>
		/// <description>Not applicable</description>
		/// </item>
		/// <item>
		/// <description>
		/// <c>*</c> For applications that have been manifested for WindowsÂ 8.1 or WindowsÂ 10. Applications not manifested for WindowsÂ 8.1 or
		/// WindowsÂ 10 will return the WindowsÂ 8 OS version value (6.2). To manifest your applications for WindowsÂ 8.1 or WindowsÂ 10, refer
		/// to Targeting your application for Windows.
		/// </description>
		/// </item>
		/// </list>
		/// <para>Â</para>
		/// <para>Examples</para>
		/// <para>For an example, see Getting the System Version.</para>
		/// <para>
		/// <para>Note</para>
		/// <para>
		/// The winnt.h header defines OSVERSIONINFO as an alias which automatically selects the ANSI or Unicode version of this function based
		/// on the definition of the UNICODE preprocessor constant. Mixing usage of the encoding-neutral alias with code that not
		/// encoding-neutral can lead to mismatches that result in compilation or runtime errors. For more information, see Conventions for
		/// Function Prototypes.
		/// </para>
		/// </para>
		/// </remarks>
		// https://learn.microsoft.com/en-us/windows/win32/api/winnt/ns-winnt-osversioninfow typedef struct _OSVERSIONINFOW { DWORD
		// dwOSVersionInfoSize; DWORD dwMajorVersion; DWORD dwMinorVersion; DWORD dwBuildNumber; DWORD dwPlatformId; WCHAR szCSDVersion[128]; }
		// OSVERSIONINFOW, *POSVERSIONINFOW, *LPOSVERSIONINFOW, RTL_OSVERSIONINFOW, *PRTL_OSVERSIONINFOW;
		[PInvokeData("winnt.h", MSDNShortId = "NS:winnt._OSVERSIONINFOW")]
		[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
		public struct OSVERSIONINFOW
		{
			/// <summary>The size of this data structure, in bytes. Set this member to .</summary>
			public uint dwOSVersionInfoSize;

			/// <summary>The major version number of the operating system. For more information, see Remarks.</summary>
			public uint dwMajorVersion;

			/// <summary>The minor version number of the operating system. For more information, see Remarks.</summary>
			public uint dwMinorVersion;

			/// <summary>The build number of the operating system.</summary>
			public uint dwBuildNumber;

			/// <summary>
			/// <para>The operating system platform. This member can be the following value.</para>
			/// <list type="table">
			/// <listheader>
			/// <description>Value</description>
			/// <description>Meaning</description>
			/// </listheader>
			/// <item>
			/// <description><c>VER_PLATFORM_WIN32_NT</c> 2</description>
			/// <description>
			/// The operating system is WindowsÂ 7, Windows ServerÂ 2008, WindowsÂ Vista, Windows ServerÂ 2003, WindowsÂ XP, or WindowsÂ 2000.
			/// </description>
			/// </item>
			/// </list>
			/// </summary>
			public uint dwPlatformId;

			/// <summary>
			/// A null-terminated string, such as "Service Pack 3", that indicates the latest Service Pack installed on the system. If no Service
			/// Pack has been installed, the string is empty.
			/// </summary>
			[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 128)]
			public string szCSDVersion;
		}

		/*
		ACCESS_STATE structure
		ACL structure
		ClfsCreateMarshallingAreaEx function
		DIRECTORY_NOTIFY_INFORMATION_CLASS enumeration
		DRIVER_DIRECTORY_TYPE enumeration
		ExInitializeWorkItem function
		ExQueueWorkItem function
		FAST_IO_DISPATCH structure
		FILE_INFORMATION_CLASS enumeration
		FILE_MEMORY_PARTITION_INFORMATION structure
		FILE_SFIO_RESERVE_INFORMATION structure
		FS_INFORMATION_CLASS enumeration
		IoGetTopLevelIrp function
		IoRemoveLinkShareAccessEx function
		IoSetTopLevelIrp function
		LOCK_OPERATION enumeration
		LUID_AND_ATTRIBUTES structure
		SeCaptureSubjectContext function
		SECURITY_IMPERSONATION_LEVEL enumeration
		SECURITY_SUBJECT_CONTEXT structure
		SeLockSubjectContext function
		SeReleaseSubjectContext function
		SeUnlockSubjectContext function
		VPB structure
		WORK_QUEUE_ITEM structure

		ASSERTMSG macro
		DbgBreakPoint function
		DbgBreakPointWithStatus function
		DbgPrint function
		DbgPrintEx function
		EtwActivityIdControl function
		ETWENABLECALLBACK callback function
		EtwEventEnabled function
		EtwProviderEnabled function
		EtwRegister function
		EtwUnregister function
		EtwWrite function
		EtwWriteEx function
		EtwWriteString function
		EtwWriteTransfer function
		FAULT_INFORMATION structure
		FAULT_INFORMATION_ARCH enumeration
		FAULT_INFORMATION_ARM64 structure
		FAULT_INFORMATION_ARM64_FLAGS structure
		FAULT_INFORMATION_ARM64_TYPE enumeration
		KBUGCHECK_CALLBACK_RECORD structure
		KBUGCHECK_REASON_CALLBACK_RECORD structure
		KBUGCHECK_REMOVE_PAGES structure
		KBUGCHECK_SECONDARY_DUMP_DATA_EX structure
		KBUGCHECK_TRIAGE_DUMP_DATA structure
		KdBreakPointWithStatus macro
		KdChangeOption function
		KdDisableDebugger function
		KdEnableDebugger function
		KdPrint macro
		KdPrintEx macro
		KdRefreshDebuggerNotPresent function
		KeInitializeTriageDumpDataArray function
		KTRIAGE_DUMP_DATA_ARRAY structure
		PCW_CALLBACK callback function
		PCW_CALLBACK_INFORMATION union
		PCW_CALLBACK_TYPE enumeration
		PCW_COUNTER_DESCRIPTOR structure
		PCW_COUNTER_INFORMATION structure
		PCW_DATA structure
		PCW_MASK_INFORMATION structure
		PCW_REGISTRATION_INFORMATION structure
		PcwAddInstance function
		PcwCloseInstance function
		PcwCreateInstance function
		PcwRegister function
		PcwUnregister function
		SeEtwWriteKMCveEvent function
		vDbgPrintEx function
		vDbgPrintExWithPrefix function

		DMA_ADAPTER structure
		DMA_OPERATIONS structure
		_BitTest64 function
		_BitTestAndComplement64 function
		_BitTestAndReset64 function
		_BitTestAndSet64 function
		ACPI_INTERFACE_STANDARD2 structure
		ALLOCATE_FUNCTION_EX callback function
		AppendTailList function
		ARM64_SYSREG_CRM macro
		ARM64_SYSREG_CRN macro
		ARM64_SYSREG_OP1 macro
		ARM64_SYSREG_OP2 macro
		BOOTDISK_INFORMATION structure
		BOOTDISK_INFORMATION_EX structure
		BOUND_CALLBACK callback function
		BOUND_CALLBACK_STATUS enumeration
		BUS_INTERFACE_STANDARD structure
		BUS_RESOURCE_UPDATE_INTERFACE structure
		CLFS_CONTEXT_MODE enumeration
		CLFS_LOG_NAME_INFORMATION structure
		CLFS_MGMT_CLIENT_REGISTRATION structure
		CLFS_MGMT_POLICY structure
		CLFS_MGMT_POLICY_TYPE enumeration
		CLFS_STREAM_ID_INFORMATION structure
		ClfsAddLogContainer function
		ClfsAddLogContainerSet function
		ClfsAdvanceLogBase function
		ClfsAlignReservedLog function
		ClfsAllocReservedLog function
		ClfsCloseAndResetLogFile function
		ClfsCloseLogFileObject function
		ClfsCreateLogFile function
		ClfsCreateMarshallingArea function
		ClfsCreateScanContext function
		ClfsDeleteLogByPointer function
		ClfsDeleteLogFile function
		ClfsDeleteMarshallingArea function
		ClfsFlushBuffers function
		ClfsFlushToLsn function
		ClfsGetContainerName function
		ClfsGetIoStatistics function
		ClfsLsnBlockOffset function
		ClfsLsnContainer function
		ClfsLsnCreate function
		ClfsLsnEqual function
		ClfsLsnGreater function
		ClfsLsnLess function
		ClfsLsnNull function
		ClfsLsnRecordSequence function
		ClfsMgmtDeregisterManagedClient function
		ClfsMgmtHandleLogFileFull function
		ClfsMgmtInstallPolicy function
		ClfsMgmtQueryPolicy function
		ClfsMgmtRegisterManagedClient function
		ClfsMgmtRemovePolicy function
		ClfsMgmtSetLogFileSize function
		ClfsMgmtSetLogFileSizeAsClient function
		ClfsMgmtTailAdvanceFailure function
		ClfsQueryLogFileInformation function
		ClfsReadLogRecord function
		ClfsReadNextLogRecord function
		ClfsReadPreviousRestartArea function
		ClfsReadRestartArea function
		ClfsRemoveLogContainer function
		ClfsRemoveLogContainerSet function
		ClfsReserveAndAppendLog function
		ClfsReserveAndAppendLogAligned function
		ClfsScanLogContainers function
		ClfsSetArchiveTail function
		ClfsSetEndOfLog function
		ClfsSetLogFileInformation function
		ClfsTerminateReadLog function
		ClfsWriteRestartArea function
		CLS_CONTAINER_INFORMATION structure
		CLS_INFORMATION structure
		CLS_IO_STATISTICS structure
		CLS_IO_STATISTICS_HEADER structure
		CLS_LOG_INFORMATION_CLASS enumeration
		CLS_LSN structure
		CLS_SCAN_CONTEXT structure
		CLS_WRITE_ENTRY structure
		CM_EISA_FUNCTION_INFORMATION structure
		CM_EISA_SLOT_INFORMATION structure
		CM_FLOPPY_DEVICE_DATA structure
		CM_FULL_RESOURCE_DESCRIPTOR structure
		CM_INT13_DRIVE_PARAMETER structure
		CM_KEYBOARD_DEVICE_DATA structure
		CM_MCA_POS_DATA structure
		CM_PARTIAL_RESOURCE_DESCRIPTOR structure
		CM_PARTIAL_RESOURCE_LIST structure
		CM_POWER_DATA structure
		CM_RESOURCE_LIST structure
		CM_SCSI_DEVICE_DATA structure
		CM_SERIAL_DEVICE_DATA structure
		CmCallbackGetKeyObjectID function
		CmCallbackGetKeyObjectIDEx function
		CmCallbackReleaseKeyObjectIDEx function
		CmGetBoundTransaction function
		CmGetCallbackVersion function
		CmRegisterCallback function
		CmRegisterCallbackEx function
		CmSetCallbackObjectContext function
		CmUnRegisterCallback function
		COUNTED_REASON_CONTEXT structure
		D3COLD_AUX_POWER_AND_TIMING_INTERFACE structure
		D3COLD_LAST_TRANSITION_STATUS enumeration
		D3COLD_REQUEST_AUX_POWER callback function
		D3COLD_REQUEST_CORE_POWER_RAIL callback function
		D3COLD_REQUEST_PERST_DELAY callback function
		D3COLD_SUPPORT_INTERFACE structure
		DEVICE_BUS_SPECIFIC_RESET_INFO structure
		DEVICE_BUS_SPECIFIC_RESET_TYPE union
		DEVICE_CAPABILITIES structure
		DEVICE_DESCRIPTION structure
		DEVICE_DIRECTORY_TYPE enumeration
		DEVICE_FAULT_CONFIGURATION structure
		DEVICE_INSTALL_STATE enumeration
		DEVICE_INTERFACE_CHANGE_NOTIFICATION structure
		DEVICE_OBJECT structure
		DEVICE_POWER_STATE enumeration
		DEVICE_REGISTRY_PROPERTY enumeration
		DEVICE_REMOVAL_POLICY enumeration
		DEVICE_RESET_INTERFACE_STANDARD structure
		DEVICE_RESET_TYPE enumeration
		DEVICE_USAGE_NOTIFICATION_TYPE enumeration
		DEVICE_WAKE_DEPTH enumeration
		DMA_ADAPTER_INFO structure
		DMA_ADAPTER_INFO_V1 structure
		DMA_COMMON_BUFFER_EXTENDED_CONFIGURATION_TYPE enumeration
		DMA_COMPLETION_ROUTINE callback function
		DMA_COMPLETION_STATUS enumeration
		DMA_IOMMU_INTERFACE structure
		DMA_IOMMU_INTERFACE_EX structure
		DMA_IOMMU_INTERFACE_V1 structure
		DMA_IOMMU_INTERFACE_V2 structure
		DMA_TRANSFER_INFO structure
		DMA_TRANSFER_INFO_V1 structure
		DMA_TRANSFER_INFO_V2 structure
		DOMAIN_CONFIGURATION structure
		DOMAIN_CONFIGURATION_ARCH enumeration
		DOMAIN_CONFIGURATION_ARM64 structure
		DOMAIN_CONFIGURATION_X64 structure
		DRIVER_ADD_DEVICE callback function
		DRIVER_CANCEL callback function
		DRIVER_CONTROL callback function
		DRIVER_DISPATCH callback function
		DRIVER_INITIALIZE callback function
		DRIVER_LIST_CONTROL callback function
		DRIVER_OBJECT structure
		DRIVER_REGKEY_TYPE enumeration
		DRIVER_STARTIO callback function
		DRIVER_UNLOAD callback function
		ENLISTMENT_BASIC_INFORMATION structure
		ENLISTMENT_INFORMATION_CLASS enumeration
		EX_CALLBACK_FUNCTION callback function
		EX_POOL_PRIORITY enumeration
		ExAcquirePushLockExclusive macro
		ExAcquirePushLockShared macro
		ExAcquireResourceExclusiveLite function
		ExAcquireResourceSharedLite function
		ExAcquireRundownProtection function
		ExAcquireRundownProtectionEx function
		ExAcquireSharedStarveExclusive function
		ExAcquireSharedWaitForExclusive function
		ExAllocateFromLookasideListEx function
		ExAllocateFromNPagedLookasideList function
		ExAllocateFromPagedLookasideList function
		ExAllocatePool function
		ExAllocatePool2 function
		ExAllocatePool3 function
		ExAllocatePoolPriorityUninitialized function
		ExAllocatePoolPriorityZero function
		ExAllocatePoolQuotaUninitialized function
		ExAllocatePoolQuotaZero function
		ExAllocatePoolUninitialized function
		ExAllocatePoolWithQuota function
		ExAllocatePoolWithQuotaTag function
		ExAllocatePoolWithTag function
		ExAllocatePoolWithTagPriority function
		ExAllocatePoolZero function
		ExAllocateTimer function
		ExCancelTimer function
		ExConvertExclusiveToSharedLite function
		ExCreateCallback function
		ExCreatePool function
		ExDeleteLookasideListEx function
		ExDeleteNPagedLookasideList function
		ExDeletePagedLookasideList function
		ExDeleteResourceLite function
		ExDeleteTimer function
		ExDestroyPool function
		ExFlushLookasideListEx function
		ExFreePool function
		ExFreePool2 function
		ExFreePoolWithTag function
		ExFreeToLookasideListEx function
		ExFreeToNPagedLookasideList function
		ExFreeToPagedLookasideList function
		ExGetExclusiveWaiterCount function
		ExGetFirmwareEnvironmentVariable function
		ExGetFirmwareType function
		ExGetPreviousMode function
		ExGetSharedWaiterCount function
		ExInitializeDeleteTimerParameters function
		ExInitializeDeviceAts function
		ExInitializeDriverRuntime function
		ExInitializeFastMutex function
		ExInitializeLookasideListEx function
		ExInitializeNPagedLookasideList function
		ExInitializePagedLookasideList function
		ExInitializePushLock function
		ExInitializeResourceLite function
		ExInitializeRundownProtection function
		ExInitializeSetTimerParameters function
		ExInterlockedAddLargeInteger function
		ExInterlockedAddLargeStatistic macro
		ExInterlockedAddUlong function
		ExInterlockedCompareExchange64 macro
		ExInterlockedFlushSList function
		ExInterlockedInsertHeadList function
		ExInterlockedInsertTailList function
		ExInterlockedPopEntryList function
		ExInterlockedPopEntrySList function
		ExInterlockedPushEntryList function
		ExInterlockedPushEntrySList function
		ExInterlockedRemoveHeadList function
		ExIsProcessorFeaturePresent function
		ExIsResourceAcquiredExclusiveLite function
		ExIsResourceAcquiredSharedLite function
		ExIsSoftBoot function
		ExLocalTimeToSystemTime function
		ExNotifyCallback function
		ExQueryDepthSList function
		ExQueryTimerResolution function
		ExRaiseStatus function
		ExRegisterCallback function
		ExReinitializeResourceLite function
		ExReInitializeRundownProtection function
		ExReleasePushLockExclusive macro
		ExReleasePushLockShared macro
		ExReleaseResourceForThreadLite function
		ExReleaseResourceLite function
		ExReleaseRundownProtection function
		ExReleaseRundownProtectionEx function
		ExReleaseSpinLockExclusive function
		ExReleaseSpinLockShared function
		ExRundownCompleted function
		ExSecurePoolUpdate function
		ExSecurePoolValidate function
		ExSetFirmwareEnvironmentVariable function
		ExSetResourceOwnerPointer function
		ExSetResourceOwnerPointerEx function
		ExSetTimer function
		ExSetTimerResolution function
		ExSystemTimeToLocalTime function
		EXT_CALLBACK callback function
		EXT_DELETE_CALLBACK callback function
		EXT_DELETE_PARAMETERS structure
		EXT_SET_PARAMETERS structure
		ExTryConvertSharedSpinLockExclusive function
		ExUnregisterCallback function
		ExWaitForRundownProtectionRelease function
		FIELD_OFFSET macro
		FILE_BASIC_INFORMATION structure
		FILE_FS_DEVICE_INFORMATION structure
		FILE_FULL_EA_INFORMATION structure
		FILE_IO_PRIORITY_HINT_INFORMATION structure
		FILE_IS_REMOTE_DEVICE_INFORMATION structure
		FILE_NETWORK_OPEN_INFORMATION structure
		FILE_OBJECT structure
		FILE_POSITION_INFORMATION structure
		FILE_STANDARD_INFORMATION structure
		FILE_STANDARD_INFORMATION_EX structure
		FirstEntrySList function
		FPGA_BUS_SCAN callback function
		FPGA_CONTROL_CONFIG_SPACE callback function
		FPGA_CONTROL_ERROR_REPORTING callback function
		FPGA_CONTROL_INTERFACE structure
		FPGA_CONTROL_LINK callback function
		FREE_FUNCTION_EX callback function
		FUNCTION_LEVEL_DEVICE_RESET_PARAMETERS structure
		GENERIC_MAPPING structure
		GET_D3COLD_CAPABILITY callback function
		GET_D3COLD_LAST_TRANSITION_STATUS callback function
		GET_DMA_ADAPTER callback function
		GET_IDLE_WAKE_INFO callback function
		GET_SDEV_IDENTIFIER callback function
		GET_SET_DEVICE_DATA callback function
		GET_UPDATED_BUS_RESOURCE callback function
		HWPROFILE_CHANGE_NOTIFICATION structure
		IMAGE_POLICY_ENTRY structure
		IMAGE_POLICY_ENTRY_TYPE enumeration
		IMAGE_POLICY_ID enumeration
		IMAGE_POLICY_METADATA structure
		IMAGE_POLICY_OVERRIDE macro
		InitializeListHead function
		InitializeSListHead function
		INPUT_MAPPING_ELEMENT structure
		InsertHeadList function
		InsertTailList function
		INTERFACE structure
		INTERFACE_TYPE enumeration
		InterlockedAnd function
		InterlockedCompareExchange function
		InterlockedCompareExchangePointer function
		InterlockedDecrement function
		InterlockedExchange function
		InterlockedExchangeAdd function
		InterlockedExchangePointer function
		InterlockedIncrement function
		InterlockedOr function
		InterlockedXor function
		IO_ACCESS_MODE enumeration
		IO_ACCESS_TYPE enumeration
		IO_ALLOCATION_ACTION enumeration
		IO_COMPLETION_ROUTINE callback function
		IO_CONNECT_INTERRUPT_PARAMETERS structure
		IO_CONTAINER_INFORMATION_CLASS enumeration
		IO_CONTAINER_NOTIFICATION_CLASS enumeration
		IO_CSQ_ACQUIRE_LOCK callback function
		IO_CSQ_COMPLETE_CANCELED_IRP callback function
		IO_CSQ_INSERT_IRP callback function
		IO_CSQ_INSERT_IRP_EX callback function
		IO_CSQ_PEEK_NEXT_IRP callback function
		IO_CSQ_RELEASE_LOCK callback function
		IO_CSQ_REMOVE_IRP callback function
		IO_DISCONNECT_INTERRUPT_PARAMETERS structure
		IO_DPC_ROUTINE callback function
		IO_ERROR_LOG_PACKET structure
		IO_INTERRUPT_MESSAGE_INFO structure
		IO_INTERRUPT_MESSAGE_INFO_ENTRY structure
		IO_NOTIFICATION_EVENT_CATEGORY enumeration
		IO_PAGING_PRIORITY enumeration
		IO_PRIORITY_HINT enumeration
		IO_REPORT_INTERRUPT_ACTIVE_STATE_PARAMETERS structure
		IO_RESOURCE_DESCRIPTOR structure
		IO_RESOURCE_LIST structure
		IO_RESOURCE_REQUIREMENTS_LIST structure
		IO_SECURITY_CONTEXT structure
		IO_SESSION_CONNECT_INFO structure
		IO_SESSION_EVENT enumeration
		IO_SESSION_NOTIFICATION_FUNCTION callback function
		IO_SESSION_STATE enumeration
		IO_SESSION_STATE_INFORMATION structure
		IO_SESSION_STATE_NOTIFICATION structure
		IO_STACK_LOCATION structure
		IO_STATUS_BLOCK structure
		IO_STATUS_BLOCK64 structure
		IO_TIMER_ROUTINE callback function
		IO_WORKITEM_ROUTINE callback function
		IO_WORKITEM_ROUTINE_EX callback function
		IoAcquireKsrPersistentMemory function
		IoAcquireKsrPersistentMemoryEx function
		IoAcquireRemoveLock macro
		IoAdjustPagingPathCount macro
		IoAllocateDriverObjectExtension function
		IoAllocateErrorLogEntry function
		IoAllocateIrp function
		IoAllocateIrpEx function
		IoAllocateMdl function
		IoAllocateWorkItem function
		IoAttachDevice function
		IoAttachDeviceToDeviceStack function
		IoBuildAsynchronousFsdRequest function
		IoBuildDeviceIoControlRequest function
		IoBuildPartialMdl function
		IoBuildSynchronousFsdRequest function
		IoCallDriver macro
		IoCancelIrp function
		IoCheckLinkShareAccess function
		IoCheckShareAccess function
		IoCheckShareAccessEx function
		IoConnectInterrupt function
		IoConnectInterruptEx function
		IoCopyCurrentIrpStackLocationToNext function
		IoCreateDevice function
		IoCreateFile function
		IoCreateNotificationEvent function
		IoCreateSymbolicLink function
		IoCreateSynchronizationEvent function
		IoCreateSystemThread function
		IoCreateUnprotectedSymbolicLink function
		IoCsqInitialize function
		IoCsqInitializeEx function
		IoCsqInsertIrp function
		IoCsqInsertIrpEx function
		IoCsqRemoveIrp function
		IoCsqRemoveNextIrp function
		IoDeleteDevice function
		IoDeleteSymbolicLink function
		IoDetachDevice function
		IoDisconnectInterrupt function
		IoDisconnectInterruptEx function
		IoEnumerateKsrPersistentMemoryEx function
		IofCallDriver function
		IofCompleteRequest function
		IoForwardIrpSynchronously function
		IoFreeErrorLogEntry function
		IoFreeIrp function
		IoFreeKsrPersistentMemory function
		IoFreeMdl function
		IoFreeWorkItem function
		IoGetAffinityInterrupt function
		IoGetAttachedDeviceReference function
		IoGetBootDiskInformation function
		IoGetContainerInformation function
		IoGetCurrentIrpStackLocation function
		IoGetCurrentProcess function
		IoGetDeviceDirectory function
		IoGetDeviceInterfaceAlias function
		IoGetDeviceInterfacePropertyData function
		IoGetDeviceInterfaces function
		IoGetDeviceNumaNode function
		IoGetDeviceObjectPointer function
		IoGetDeviceProperty function
		IoGetDevicePropertyData function
		IoGetDmaAdapter function
		IoGetDriverDirectory function
		IoGetDriverObjectExtension function
		IoGetFunctionCodeFromCtlCode macro
		IoGetInitialStack function
		IoGetIommuInterface function
		IoGetIommuInterfaceEx function
		IoGetIoPriorityHint function
		IoGetNextIrpStackLocation function
		IoGetRelatedDeviceObject function
		IoGetRemainingStackSize function
		IoGetStackLimits function
		IoInitializeDpcRequest function
		IoInitializeIrp function
		IoInitializeRemoveLock macro
		IoInitializeTimer function
		IoInitializeWorkItem function
		IoInvalidateDeviceRelations function
		IoInvalidateDeviceState function
		IoIs32bitProcess function
		IoIsErrorUserInduced macro
		IoIsWdmVersionAvailable function
		IoMarkIrpPending function
		IOMMU_DEVICE_CREATE callback function
		IOMMU_DEVICE_CREATION_CONFIGURATION structure
		IOMMU_DEVICE_CREATION_CONFIGURATION_ACPI structure
		IOMMU_DEVICE_CREATION_CONFIGURATION_TYPE enumeration
		IOMMU_DEVICE_DELETE callback function
		IOMMU_DEVICE_FAULT_HANDLER callback function
		IOMMU_DEVICE_QUERY_DOMAIN_TYPES callback function
		IOMMU_DMA_DOMAIN_CREATION_FLAGS union
		IOMMU_DMA_DOMAIN_TYPE enumeration
		IOMMU_DMA_LOGICAL_ADDRESS_TOKEN structure
		IOMMU_DMA_LOGICAL_ADDRESS_TOKEN_MAPPED_SEGMENT structure
		IOMMU_DMA_LOGICAL_ALLOCATOR_CONFIG structure
		IOMMU_DMA_LOGICAL_ALLOCATOR_TYPE enumeration
		IOMMU_DMA_RESERVED_REGION structure
		IOMMU_DOMAIN_ATTACH_DEVICE callback function
		IOMMU_DOMAIN_ATTACH_DEVICE_EX callback function
		IOMMU_DOMAIN_CONFIGURE callback function
		IOMMU_DOMAIN_CREATE callback function
		IOMMU_DOMAIN_CREATE_EX callback function
		IOMMU_DOMAIN_DELETE callback function
		IOMMU_DOMAIN_DETACH_DEVICE callback function
		IOMMU_DOMAIN_DETACH_DEVICE_EX callback function
		IOMMU_FLUSH_DOMAIN callback function
		IOMMU_FLUSH_DOMAIN_VA_LIST callback function
		IOMMU_FREE_RESERVED_LOGICAL_ADDRESS_RANGE callback function
		IOMMU_INTERFACE_STATE_CHANGE structure
		IOMMU_INTERFACE_STATE_CHANGE_CALLBACK callback function
		IOMMU_INTERFACE_STATE_CHANGE_FIELDS union
		IOMMU_MAP_IDENTITY_RANGE callback function
		IOMMU_MAP_IDENTITY_RANGE_EX callback function
		IOMMU_MAP_LOGICAL_RANGE callback function
		IOMMU_MAP_LOGICAL_RANGE_EX callback function
		IOMMU_MAP_PHYSICAL_ADDRESS structure
		IOMMU_MAP_PHYSICAL_ADDRESS_TYPE enumeration
		IOMMU_MAP_RESERVED_LOGICAL_RANGE callback function
		IOMMU_QUERY_INPUT_MAPPINGS callback function
		IOMMU_REGISTER_INTERFACE_STATE_CHANGE_CALLBACK callback function
		IOMMU_RESERVE_LOGICAL_ADDRESS_RANGE callback function
		IOMMU_SET_DEVICE_FAULT_REPORTING callback function
		IOMMU_SET_DEVICE_FAULT_REPORTING_EX callback function
		IOMMU_UNMAP_IDENTITY_RANGE callback function
		IOMMU_UNMAP_IDENTITY_RANGE_EX callback function
		IOMMU_UNMAP_LOGICAL_RANGE callback function
		IOMMU_UNMAP_RESERVED_LOGICAL_RANGE callback function
		IOMMU_UNREGISTER_INTERFACE_STATE_CHANGE_CALLBACK callback function
		IoOpenDeviceInterfaceRegistryKey function
		IoOpenDeviceRegistryKey function
		IoOpenDriverRegistryKey function
		IoQueryKsrPersistentMemorySize function
		IoQueryKsrPersistentMemorySizeEx function
		IoQueueWorkItem function
		IoQueueWorkItemEx function
		IoRegisterContainerNotification function
		IoRegisterDeviceInterface function
		IoRegisterLastChanceShutdownNotification function
		IoRegisterPlugPlayNotification function
		IoRegisterShutdownNotification function
		IoReleaseRemoveLock macro
		IoReleaseRemoveLockAndWait macro
		IoRemoveLinkShareAccess function
		IoRemoveShareAccess function
		IoReportInterruptActive function
		IoReportInterruptInactive function
		IoReportTargetDeviceChange function
		IoReportTargetDeviceChangeAsynchronous function
		IoRequestDeviceEject function
		IoRequestDpc function
		IoReserveKsrPersistentMemory function
		IoReserveKsrPersistentMemoryEx function
		IoReuseIrp function
		Iosb64ToIosb macro
		IosbToIosb64 macro
		IoSetCancelRoutine function
		IoSetCompletionRoutine function
		IoSetCompletionRoutineEx function
		IoSetDeviceInterfacePropertyData function
		IoSetDeviceInterfaceState function
		IoSetDevicePropertyData function
		IoSetIoPriorityHint function
		IoSetLinkShareAccess function
		IoSetNextIrpStackLocation function
		IoSetShareAccess function
		IoSetShareAccessEx function
		IoSetStartIoAttributes function
		IoSizeOfIrp macro
		IoSizeofWorkItem function
		IoStartNextPacket function
		IoStartNextPacketByKey function
		IoStartPacket function
		IoStartTimer function
		IoStopTimer function
		IoUninitializeWorkItem function
		IoUnregisterContainerNotification function
		IoUnregisterPlugPlayNotification function
		IoUnregisterPlugPlayNotificationEx function
		IoUnregisterShutdownNotification function
		IoUpdateLinkShareAccess function
		IoUpdateLinkShareAccessEx function
		IoUpdateShareAccess function
		IoValidateDeviceIoControlAccess function
		IoWithinStackLimits function
		IoWMIAllocateInstanceIds function
		IoWMIDeviceObjectToInstanceName function
		IoWMIDeviceObjectToProviderId function
		IoWMIExecuteMethod function
		IoWMIHandleToInstanceName function
		IoWMIOpenBlock function
		IoWMIQueryAllData function
		IoWMIQueryAllDataMultiple function
		IoWMIQuerySingleInstance function
		IoWMIQuerySingleInstanceMultiple function
		IoWMIRegistrationControl function
		IoWMISetNotificationCallback function
		IoWMISetSingleInstance function
		IoWMISetSingleItem function
		IoWMISuggestInstanceName function
		IoWMIWriteEvent function
		IoWriteErrorLogEntry function
		IoWriteKsrPersistentMemory function
		IRP structure
		IRQ_DEVICE_POLICY enumeration
		IRQ_PRIORITY enumeration
		IsListEmpty function
		KBUGCHECK_ADD_PAGES structure
		KBUGCHECK_CALLBACK_REASON enumeration
		KBUGCHECK_CALLBACK_ROUTINE callback function
		KBUGCHECK_DUMP_IO structure
		KBUGCHECK_DUMP_IO_TYPE enumeration
		KBUGCHECK_REASON_CALLBACK_ROUTINE callback function
		KBUGCHECK_SECONDARY_DUMP_DATA structure
		KDEFERRED_ROUTINE callback function
		KDPC_WATCHDOG_INFORMATION structure
		KE_PROCESSOR_CHANGE_NOTIFY_CONTEXT structure
		KeAcquireSpinLock macro
		KeAcquireSpinLockAtDpcLevel function
		KeAddTriageDumpDataBlock function
		KeAreAllApcsDisabled function
		KeAreApcsDisabled function
		KeBugCheckEx function
		KeCancelTimer function
		KeClearEvent function
		KeConvertAuxiliaryCounterToPerformanceCounter function
		KeConvertPerformanceCounterToAuxiliaryCounter function
		KeDelayExecutionThread function
		KeDeregisterBoundCallback function
		KeDeregisterBugCheckCallback function
		KeDeregisterBugCheckReasonCallback function
		KeDeregisterNmiCallback function
		KeDeregisterProcessorChangeCallback function
		KeEnterCriticalRegion function
		KeEnterGuardedRegion function
		KeFlushIoBuffers function
		KeFlushQueuedDpcs function
		KefReleaseSpinLockFromDpcLevel function
		KeGetCurrentIrql function
		KeGetCurrentNodeNumber function
		KeGetCurrentProcessorNumberEx function
		KeGetCurrentThread function
		KeGetProcessorIndexFromNumber function
		KeGetProcessorNumberFromIndex function
		KeGetRecommendedSharedDataAlignment function
		KeInitializeCrashDumpHeader function
		KeInitializeDeviceQueue function
		KeInitializeDpc function
		KeInitializeEvent function
		KeInitializeGuardedMutex function
		KeInitializeMutex function
		KeInitializeSemaphore function
		KeInitializeSpinLock function
		KeInitializeThreadedDpc function
		KeInitializeTimer function
		KeInitializeTimerEx function
		KeInsertByKeyDeviceQueue function
		KeInsertDeviceQueue function
		KeInsertQueueDpc function
		KeIpiGenericCall function
		KeIsExecutingDpc function
		KeLeaveCriticalRegion function
		KeLeaveGuardedRegion function
		KeLowerIrql function
		KeMemoryBarrier function
		KeQueryActiveGroupCount function
		KeQueryActiveProcessorCount function
		KeQueryActiveProcessorCountEx function
		KeQueryActiveProcessors function
		KeQueryAuxiliaryCounterFrequency function
		KeQueryDpcWatchdogInformation function
		KeQueryGroupAffinity function
		KeQueryHighestNodeNumber function
		KeQueryInterruptTime function
		KeQueryInterruptTimePrecise function
		KeQueryLogicalProcessorRelationship function
		KeQueryMaximumGroupCount function
		KeQueryMaximumProcessorCount function
		KeQueryMaximumProcessorCountEx function
		KeQueryNodeActiveAffinity function
		KeQueryNodeActiveAffinity2 function
		KeQueryNodeActiveProcessorCount function
		KeQueryNodeMaximumProcessorCount function
		KeQueryPerformanceCounter function
		KeQueryPriorityThread function
		KeQueryRuntimeThread function
		KeQuerySystemTime function
		KeQuerySystemTimePrecise function
		KeQueryTickCount macro
		KeQueryTimeIncrement function
		KeQueryTotalCycleTimeThread function
		KeQueryUnbiasedInterruptTime function
		KeRaiseIrql macro
		KeRaiseIrqlToDpcLevel function
		KeReadStateEvent function
		KeReadStateMutex function
		KeReadStateSemaphore function
		KeReadStateTimer function
		KeRegisterBoundCallback function
		KeRegisterBugCheckCallback function
		KeRegisterBugCheckReasonCallback function
		KeRegisterNmiCallback function
		KeRegisterProcessorChangeCallback function
		KeReleaseGuardedMutex function
		KeReleaseGuardedMutexUnsafe function
		KeReleaseInStackQueuedSpinLock function
		KeReleaseInStackQueuedSpinLockForDpc function
		KeReleaseInStackQueuedSpinLockFromDpcLevel function
		KeReleaseInterruptSpinLock function
		KeReleaseMutex function
		KeReleaseSemaphore function
		KeReleaseSpinLock function
		KeReleaseSpinLockForDpc function
		KeReleaseSpinLockFromDpcLevel function
		KeRemoveByKeyDeviceQueue function
		KeRemoveDeviceQueue function
		KeRemoveEntryDeviceQueue function
		KeRemoveQueueDpc function
		KeResetEvent function
		KeRestoreExtendedProcessorState function
		KeRestoreFloatingPointState function
		KeRevertToUserAffinityThreadEx function
		KeRevertToUserGroupAffinityThread function
		KERNEL_CET_CONTEXT structure
		KERNEL_SOFT_RESTART_NOTIFICATION structure
		KeSaveExtendedProcessorState function
		KeSaveFloatingPointState function
		KeSetCoalescableTimer function
		KeSetEvent function
		KeSetImportanceDpc function
		KeSetPriorityThread function
		KeSetSystemAffinityThread function
		KeSetSystemAffinityThreadEx function
		KeSetSystemGroupAffinityThread function
		KeSetTargetProcessorDpc function
		KeSetTargetProcessorDpcEx function
		KeSetTimer function
		KeSetTimerEx function
		KeShouldYieldProcessor function
		KeStallExecutionProcessor function
		KeSynchronizeExecution function
		KeTestSpinLock function
		KeTryToAcquireGuardedMutex function
		KeTryToAcquireSpinLockAtDpcLevel function
		KeWaitForMultipleObjects function
		KeWaitForSingleObject function
		KEY_BASIC_INFORMATION structure
		KEY_FULL_INFORMATION structure
		KEY_INFORMATION_CLASS enumeration
		KEY_NODE_INFORMATION structure
		KEY_SET_INFORMATION_CLASS enumeration
		KEY_VALUE_BASIC_INFORMATION structure
		KEY_VALUE_ENTRY structure
		KEY_VALUE_FULL_INFORMATION structure
		KEY_VALUE_INFORMATION_CLASS enumeration
		KEY_VALUE_PARTIAL_INFORMATION structure
		KEY_WRITE_TIME_INFORMATION structure
		KINTERRUPT_MODE enumeration
		KINTERRUPT_POLARITY enumeration
		KIPI_BROADCAST_WORKER callback function
		KMESSAGE_SERVICE_ROUTINE callback function
		KMUTANT structure
		KSERVICE_ROUTINE callback function
		KSTART_ROUTINE callback function
		KSYNCHRONIZE_ROUTINE callback function
		KTMOBJECT_CURSOR structure
		KTMOBJECT_TYPE enumeration
		KzLowerIrql function
		KzRaiseIrql function
		LINK_SHARE_ACCESS structure
		MAILSLOT_CREATE_PARAMETERS structure
		MDL structure
		MEM_EXTENDED_PARAMETER structure
		MEM_EXTENDED_PARAMETER_TYPE enumeration
		MEM_SECTION_EXTENDED_PARAMETER_TYPE enumeration
		MEMORY_CACHING_TYPE enumeration
		MEMORY_PARTITION_DEDICATED_MEMORY_OPEN_INFORMATION structure
		MM_MDL_ROUTINE callback function
		MM_PHYSICAL_ADDRESS_LIST structure
		MmAdvanceMdl function
		MmAllocateContiguousMemory function
		MmAllocateContiguousMemoryEx function
		MmAllocateContiguousMemorySpecifyCache function
		MmAllocateContiguousMemorySpecifyCacheNode function
		MmAllocateContiguousNodeMemory function
		MmAllocateMappingAddress function
		MmAllocateMappingAddressEx function
		MmAllocateMdlForIoSpace function
		MmAllocateNodePagesForMdlEx function
		MmAllocatePagesForMdl function
		MmAllocatePagesForMdlEx function
		MmBuildMdlForNonPagedPool function
		MmFreeContiguousMemory function
		MmFreeContiguousMemorySpecifyCache function
		MmFreeMappingAddress function
		MmFreePagesFromMdl function
		MmGetMdlByteCount macro
		MmGetSystemAddressForMdl macro
		MmGetSystemRoutineAddress function
		MmGetSystemRoutineAddressEx function
		MmIsDriverSuspectForVerifier function
		MmIsDriverVerifying function
		MmIsDriverVerifyingByAddress function
		MmLockPagableCodeSection macro
		MmLockPagableDataSection function
		MmMapIoSpace function
		MmMapIoSpaceEx function
		MmMapLockedPages function
		MmMapLockedPagesSpecifyCache function
		MmMapLockedPagesWithReservedMapping function
		MmMapMdl function
		MmMapMemoryDumpMdlEx function
		MmPageEntireDriver function
		MmProbeAndLockPages function
		MmProbeAndLockSelectedPages function
		MmProtectDriverSection function
		MmProtectMdlSystemAddress function
		MmQuerySystemSize function
		MmResetDriverPaging function
		MmSizeOfMdl function
		MmUnlockPagableImageSection function
		MmUnlockPages function
		MmUnmapIoSpace function
		MmUnmapLockedPages function
		MmUnmapReservedMapping function
		MONITOR_DISPLAY_STATE enumeration
		NAMED_PIPE_CREATE_PARAMETERS structure
		NtCommitComplete function
		NtCommitEnlistment function
		NtCommitTransaction function
		NtCreateEnlistment function
		NtCreateResourceManager function
		NtCreateTransaction function
		NtCreateTransactionManager function
		NtEnumerateTransactionObject function
		NtGetNotificationResourceManager function
		NtManagePartition function
		NtOpenEnlistment function
		NtOpenResourceManager function
		NtOpenTransaction function
		NtOpenTransactionManager function
		NtPowerInformation function
		NtPrepareComplete function
		NtPrepareEnlistment function
		NtPrePrepareComplete function
		NtPrePrepareEnlistment function
		NtQueryInformationEnlistment function
		NtQueryInformationResourceManager function
		NtQueryInformationTransaction function
		NtQueryInformationTransactionManager function
		NtReadOnlyEnlistment function
		NtRecoverEnlistment function
		NtRecoverResourceManager function
		NtRecoverTransactionManager function
		NtRenameTransactionManager function
		NtRollbackComplete function
		NtRollbackEnlistment function
		NtRollbackTransaction function
		NtRollforwardTransactionManager function
		NtSetInformationEnlistment function
		NtSetInformationResourceManager function
		NtSetInformationTransaction function
		NtSetInformationTransactionManager function
		NtSinglePhaseReject function
		OB_CALLBACK_REGISTRATION structure
		OB_OPERATION_REGISTRATION structure
		OB_POST_CREATE_HANDLE_INFORMATION structure
		OB_POST_DUPLICATE_HANDLE_INFORMATION structure
		OB_POST_OPERATION_INFORMATION structure
		OB_POST_OPERATION_PARAMETERS union
		OB_PRE_CREATE_HANDLE_INFORMATION structure
		OB_PRE_DUPLICATE_HANDLE_INFORMATION structure
		OB_PRE_OPERATION_INFORMATION structure
		OB_PRE_OPERATION_PARAMETERS union
		ObCloseHandle function
		ObDereferenceObject macro
		ObDereferenceObjectDeferDelete function
		ObDereferenceObjectDeferDeleteWithTag function
		ObDereferenceObjectWithTag macro
		ObfReferenceObject function
		ObGetObjectSecurity function
		ObReferenceObject macro
		ObReferenceObjectByHandle function
		ObReferenceObjectByHandleWithTag function
		ObReferenceObjectByPointer function
		ObReferenceObjectByPointerWithTag function
		ObReferenceObjectSafe function
		ObReferenceObjectWithTag macro
		ObRegisterCallbacks function
		ObReleaseObjectSecurity function
		ObUnRegisterCallbacks function
		OSVERSIONINFOEXW structure
		OSVERSIONINFOW structure
		PALLOCATE_ADAPTER_CHANNEL callback function
		PALLOCATE_ADAPTER_CHANNEL_EX callback function
		PALLOCATE_COMMON_BUFFER callback function
		PALLOCATE_COMMON_BUFFER_EX callback function
		PALLOCATE_COMMON_BUFFER_VECTOR callback function
		PALLOCATE_COMMON_BUFFER_WITH_BOUNDS callback function
		PALLOCATE_DOMAIN_COMMON_BUFFER callback function
		PBUILD_MDL_FROM_SCATTER_GATHER_LIST callback function
		PBUILD_SCATTER_GATHER_LIST callback function
		PBUILD_SCATTER_GATHER_LIST_EX callback function
		PCALCULATE_SCATTER_GATHER_LIST_SIZE callback function
		PCANCEL_ADAPTER_CHANNEL callback function
		PCANCEL_MAPPED_TRANSFER callback function
		PCI_ATS_INTERFACE structure
		PCI_COMMON_CONFIG structure
		PCI_MSIX_MASKUNMASK_ENTRY callback function
		PCI_MSIX_SET_ENTRY callback function
		PCI_MSIX_TABLE_CONFIG_INTERFACE structure
		PCI_SECURITY_INTERFACE2 structure
		PCI_SEGMENT_BUS_NUMBER structure
		PCI_SLOT_NUMBER structure
		PCLFS_CLIENT_ADVANCE_TAIL_CALLBACK callback function
		PCLFS_CLIENT_LFF_HANDLER_COMPLETE_CALLBACK callback function
		PCLFS_CLIENT_LOG_UNPINNED_CALLBACK callback function
		PCONFIGURE_ADAPTER_CHANNEL callback function
		PDEVICE_RESET_HANDLER callback function
		PFLUSH_ADAPTER_BUFFERS callback function
		PFLUSH_ADAPTER_BUFFERS_EX callback function
		PFLUSH_DMA_BUFFER callback function
		PFREE_ADAPTER_CHANNEL callback function
		PFREE_ADAPTER_OBJECT callback function
		PFREE_COMMON_BUFFER callback function
		PFREE_COMMON_BUFFER_FROM_VECTOR callback function
		PFREE_COMMON_BUFFER_VECTOR callback function
		PFREE_MAP_REGISTERS callback function
		PGET_COMMON_BUFFER_FROM_VECTOR_BY_INDEX callback function
		PGET_DEVICE_RESET_STATUS callback function
		PGET_DMA_ADAPTER_INFO callback function
		PGET_DMA_ALIGNMENT callback function
		PGET_DMA_DOMAIN callback function
		PGET_DMA_TRANSFER_INFO callback function
		PGET_SCATTER_GATHER_LIST callback function
		PGET_SCATTER_GATHER_LIST_EX callback function
		PINITIALIZE_DMA_TRANSFER_CONTEXT callback function
		PINTERFACE_DEREFERENCE callback function
		PINTERFACE_REFERENCE callback function
		PJOIN_DMA_DOMAIN callback function
		PLEAVE_DMA_DOMAIN callback function
		PLUGPLAY_NOTIFICATION_HEADER structure
		PMAP_TRANSFER callback function
		PMAP_TRANSFER_EX callback function
		PNP_BUS_INFORMATION structure
		PO_FX_COMPONENT_ACTIVE_CONDITION_CALLBACK callback function
		PO_FX_COMPONENT_CRITICAL_TRANSITION_CALLBACK callback function
		PO_FX_COMPONENT_IDLE_CONDITION_CALLBACK callback function
		PO_FX_COMPONENT_IDLE_STATE structure
		PO_FX_COMPONENT_IDLE_STATE_CALLBACK callback function
		PO_FX_COMPONENT_PERF_INFO structure
		PO_FX_COMPONENT_PERF_SET structure
		PO_FX_COMPONENT_PERF_STATE_CALLBACK callback function
		PO_FX_COMPONENT_V1 structure
		PO_FX_COMPONENT_V2 structure
		PO_FX_DEVICE_POWER_NOT_REQUIRED_CALLBACK callback function
		PO_FX_DEVICE_POWER_REQUIRED_CALLBACK callback function
		PO_FX_DEVICE_V1 structure
		PO_FX_DEVICE_V2 structure
		PO_FX_DEVICE_V3 structure
		PO_FX_DIRECTED_POWER_DOWN_CALLBACK callback function
		PO_FX_DIRECTED_POWER_UP_CALLBACK callback function
		PO_FX_PERF_STATE structure
		PO_FX_PERF_STATE_CHANGE structure
		PO_FX_PERF_STATE_TYPE enumeration
		PO_FX_PERF_STATE_UNIT enumeration
		PO_FX_POWER_CONTROL_CALLBACK callback function
		POB_POST_OPERATION_CALLBACK callback function
		POB_PRE_OPERATION_CALLBACK callback function
		PoCallDriver function
		PoClearPowerRequest function
		PoCreatePowerRequest function
		PoDeletePowerRequest function
		PoEndDeviceBusy function
		PoFxActivateComponent function
		PoFxCompleteDevicePowerNotRequired function
		PoFxCompleteDirectedPowerDown function
		PoFxCompleteIdleCondition function
		PoFxCompleteIdleState function
		PoFxIdleComponent function
		PoFxIssueComponentPerfStateChange function
		PoFxIssueComponentPerfStateChangeMultiple function
		PoFxNotifySurprisePowerOn function
		PoFxPowerControl function
		PoFxPowerOnCrashdumpDevice function
		PoFxQueryCurrentComponentPerfState function
		PoFxRegisterComponentPerfStates function
		PoFxRegisterCrashdumpDevice function
		PoFxRegisterDevice function
		PoFxReportDevicePoweredOn function
		PoFxSetComponentLatency function
		PoFxSetComponentResidency function
		PoFxSetComponentWake function
		PoFxSetDeviceIdleTimeout function
		PoFxSetTargetDripsDevicePowerState function
		PoFxStartDevicePowerManagement function
		PoFxUnregisterDevice function
		PoGetSystemWake function
		POOL_CREATE_EXTENDED_PARAMS structure
		POOL_EXTENDED_PARAMETER structure
		POOL_EXTENDED_PARAMETER_TYPE enumeration
		POOL_EXTENDED_PARAMS_SECURE_POOL structure
		POOL_TYPE enumeration
		PopEntryList function
		PoQueryWatchdogTime function
		PoRegisterDeviceForIdleDetection function
		PoRegisterPowerSettingCallback function
		PoRegisterSystemState function
		PoRequestPowerIrp function
		PoSetDeviceBusyEx function
		PoSetPowerRequest function
		PoSetPowerState function
		PoSetSystemState function
		PoSetSystemWake function
		PoSetSystemWakeDevice function
		PoStartDeviceBusy function
		PoStartNextPowerIrp function
		PoUnregisterPowerSettingCallback function
		PoUnregisterSystemState function
		POWER_ACTION enumeration
		POWER_INFORMATION_LEVEL enumeration
		POWER_PLATFORM_INFORMATION structure
		POWER_REQUEST_TYPE enumeration
		POWER_SESSION_ALLOW_EXTERNAL_DMA_DEVICES structure
		POWER_STATE union
		POWER_STATE_TYPE enumeration
		PPUT_DMA_ADAPTER callback function
		PPUT_SCATTER_GATHER_LIST callback function
		PREAD_DMA_COUNTER callback function
		PREENUMERATE_SELF callback function
		PRIVILEGE_SET structure
		ProbeForRead function
		ProbeForWrite function
		PROCESSOR_HALT_ROUTINE callback function
		PsAllocateAffinityToken function
		PsCreateSystemThread function
		PsFreeAffinityToken function
		PsGetCurrentThread function
		PsGetVersion function
		PsQueryTotalCycleTimeProcess function
		PsRevertToUserMultipleGroupAffinityThread function
		PsSetSystemMultipleGroupAffinityThread function
		PsTerminateSystemThread function
		PTM_CONTROL_INTERFACE structure
		PTM_RM_NOTIFICATION callback function
		PushEntryList function
		READ_PORT_BUFFER_UCHAR function
		READ_PORT_BUFFER_ULONG function
		READ_PORT_BUFFER_USHORT function
		READ_PORT_UCHAR function
		READ_PORT_ULONG function
		READ_PORT_USHORT function
		READ_REGISTER_BUFFER_UCHAR function
		READ_REGISTER_BUFFER_ULONG function
		READ_REGISTER_BUFFER_ULONG64 function
		READ_REGISTER_BUFFER_USHORT function
		READ_REGISTER_UCHAR function
		READ_REGISTER_ULONG function
		READ_REGISTER_ULONG64 function
		READ_REGISTER_USHORT function
		ReadInt32Acquire function
		ReadInt32NoFence function
		ReadInt32Raw function
		ReadUInt32Acquire function
		ReadUInt32NoFence function
		ReadUInt32Raw function
		REENUMERATE_SELF_INTERFACE_STANDARD structure
		REG_CALLBACK_CONTEXT_CLEANUP_INFORMATION structure
		REG_CREATE_KEY_INFORMATION structure
		REG_CREATE_KEY_INFORMATION_V1 structure
		REG_DELETE_KEY_INFORMATION structure
		REG_DELETE_VALUE_KEY_INFORMATION structure
		REG_ENUMERATE_KEY_INFORMATION structure
		REG_ENUMERATE_VALUE_KEY_INFORMATION structure
		REG_KEY_HANDLE_CLOSE_INFORMATION structure
		REG_LOAD_KEY_INFORMATION structure
		REG_LOAD_KEY_INFORMATION_V2 structure
		REG_NOTIFY_CLASS enumeration
		REG_POST_CREATE_KEY_INFORMATION structure
		REG_POST_OPERATION_INFORMATION structure
		REG_PRE_CREATE_KEY_INFORMATION structure
		REG_QUERY_KEY_INFORMATION structure
		REG_QUERY_KEY_NAME structure
		REG_QUERY_KEY_SECURITY_INFORMATION structure
		REG_QUERY_MULTIPLE_VALUE_KEY_INFORMATION structure
		REG_QUERY_VALUE_KEY_INFORMATION structure
		REG_RENAME_KEY_INFORMATION structure
		REG_REPLACE_KEY_INFORMATION structure
		REG_RESTORE_KEY_INFORMATION structure
		REG_SAVE_KEY_INFORMATION structure
		REG_SAVE_MERGED_KEY_INFORMATION structure
		REG_SET_INFORMATION_KEY_INFORMATION structure
		REG_SET_KEY_SECURITY_INFORMATION structure
		REG_SET_VALUE_KEY_INFORMATION structure
		REG_UNLOAD_KEY_INFORMATION structure
		RemoveEntryList function
		RemoveHeadList function
		RemoveTailList function
		REQUEST_POWER_COMPLETE callback function
		RESOURCEMANAGER_BASIC_INFORMATION structure
		RESOURCEMANAGER_COMPLETION_INFORMATION structure
		RESOURCEMANAGER_INFORMATION_CLASS enumeration
		RTL_QUERY_REGISTRY_ROUTINE callback function
		RtlAnsiStringToUnicodeSize macro
		RtlAnsiStringToUnicodeString function
		RtlAppendUnicodeStringToString function
		RtlAppendUnicodeToString function
		RtlAreBitsClear function
		RtlAreBitsSet function
		RtlCheckBit function
		RtlCheckRegistryKey function
		RtlClearAllBits function
		RtlClearBit function
		RtlClearBits function
		RtlCmDecodeMemIoResource function
		RtlCmEncodeMemIoResource function
		RtlCompareMemory function
		RtlCompareUnicodeString function
		RtlConvertLongToLargeInteger function
		RtlConvertUlongToLargeInteger function
		RtlCopyMemory macro
		RtlCopyMemoryNonTemporal function
		RtlCopyUnicodeString function
		RtlCreateRegistryKey function
		RtlCreateSecurityDescriptor function
		RtlDeleteRegistryValue function
		RtlDowncaseUnicodeChar function
		RtlEqualMemory macro
		RtlEqualUnicodeString function
		RtlFillMemory macro
		RtlFillMemoryNonTemporal function
		RtlFindClearBits function
		RtlFindClearBitsAndSet function
		RtlFindClearRuns function
		RtlFindFirstRunClear function
		RtlFindLastBackwardRunClear function
		RtlFindLeastSignificantBit function
		RtlFindLongestRunClear function
		RtlFindMostSignificantBit function
		RtlFindNextForwardRunClear function
		RtlFindSetBits function
		RtlFindSetBitsAndClear function
		RtlFreeAnsiString function
		RtlFreeUnicodeString function
		RtlFreeUTF8String function
		RtlGetVersion function
		RtlGUIDFromString function
		RtlHashUnicodeString function
		RtlInitAnsiString function
		RtlInitializeBitMap function
		RtlInitString function
		RtlInitStringEx function
		RtlInitUnicodeString function
		RtlInitUTF8String function
		RtlInitUTF8StringEx function
		RtlInt64ToUnicodeString function
		RtlIntegerToUnicodeString function
		RtlIntPtrToUnicodeString macro
		RtlIoDecodeMemIoResource function
		RtlIoEncodeMemIoResource function
		RtlIsNtDdiVersionAvailable function
		RtlIsServicePackVersionInstalled function
		RtlLengthSecurityDescriptor function
		RtlMoveMemory macro
		RtlNumberOfClearBits function
		RtlNumberOfSetBits function
		RtlNumberOfSetBitsUlongPtr function
		RtlPrefetchMemoryNonTemporal function
		RtlQueryRegistryValues function
		RtlSanitizeUnicodeStringPadding function
		RtlSecureZeroMemory function
		RtlSetAllBits function
		RtlSetBit function
		RtlSetBits function
		RtlSetDaclSecurityDescriptor function
		RtlStringFromGUID function
		RtlTestBit function
		RtlTimeFieldsToTime function
		RtlTimeToTimeFields function
		RtlUlongByteSwap function
		RtlUlonglongByteSwap function
		RtlUnicodeStringToAnsiSize macro
		RtlUnicodeStringToAnsiString function
		RtlUnicodeStringToInteger function
		RtlUnicodeStringToUTF8String function
		RtlUnicodeToUTF8N function
		RtlUpcaseUnicodeChar function
		RtlUshortByteSwap function
		RtlUTF8StringToUnicodeString function
		RtlUTF8ToUnicodeN function
		RtlValidRelativeSecurityDescriptor function
		RtlValidSecurityDescriptor function
		RtlVerifyVersionInfo function
		RtlWriteRegistryValue function
		RtlxAnsiStringToUnicodeSize function
		RtlxUnicodeStringToAnsiSize function
		RtlZeroMemory macro
		SCATTER_GATHER_LIST structure
		SDEV_IDENTIFIER_INTERFACE structure
		SE_IMAGE_TYPE enumeration
		SeAccessCheck function
		SeAssignSecurity function
		SeAssignSecurityEx function
		SECTION_OBJECT_POINTERS structure
		SeDeassignSecurity function
		SET_D3COLD_SUPPORT callback function
		SeValidSecurityDescriptor function
		SLIST_ENTRY structure
		SYSTEM_POOL_ZEROING_INFORMATION structure
		SYSTEM_POWER_STATE enumeration
		SYSTEM_POWER_STATE_CONTEXT structure
		TARGET_DEVICE_CUSTOM_NOTIFICATION structure
		TARGET_DEVICE_REMOVAL_NOTIFICATION structure
		TIME_FIELDS structure
		TmCommitComplete function
		TmCommitEnlistment function
		TmCommitTransaction function
		TmCreateEnlistment function
		TmDereferenceEnlistmentKey function
		TmEnableCallbacks function
		TmGetTransactionId function
		TmInitializeTransactionManager function
		TmIsTransactionActive function
		TmPrepareComplete function
		TmPrepareEnlistment function
		TmPrePrepareComplete function
		TmPrePrepareEnlistment function
		TmReadOnlyEnlistment function
		TmRecoverEnlistment function
		TmRecoverResourceManager function
		TmRecoverTransactionManager function
		TmReferenceEnlistmentKey function
		TmRenameTransactionManager function
		TmRequestOutcomeEnlistment function
		TmRollbackComplete function
		TmRollbackEnlistment function
		TmRollbackTransaction function
		TmSinglePhaseReject function
		TRACE_INFORMATION_CLASS enumeration
		TRANSACTION_BASIC_INFORMATION structure
		TRANSACTION_ENLISTMENT_PAIR structure
		TRANSACTION_ENLISTMENTS_INFORMATION structure
		TRANSACTION_INFORMATION_CLASS enumeration
		TRANSACTION_OUTCOME enumeration
		TRANSACTION_PROPERTIES_INFORMATION structure
		TRANSACTION_STATE enumeration
		TRANSACTIONMANAGER_BASIC_INFORMATION structure
		TRANSACTIONMANAGER_INFORMATION_CLASS enumeration
		TRANSACTIONMANAGER_LOG_INFORMATION structure
		TRANSACTIONMANAGER_LOGPATH_INFORMATION structure
		TRANSACTIONMANAGER_RECOVERY_INFORMATION structure
		TRANSLATE_BUS_ADDRESS callback function
		VslCreateSecureSection function
		VslDeleteSecureSection function
		WAIT_CONTEXT_BLOCK structure
		WmiQueryTraceInformation function
		WmiTraceMessage function
		WmiTraceMessageVa function
		WORK_QUEUE_TYPE enumeration
		WRITE_PORT_BUFFER_UCHAR function
		WRITE_PORT_BUFFER_ULONG function
		WRITE_PORT_BUFFER_USHORT function
		WRITE_PORT_UCHAR function
		WRITE_PORT_ULONG function
		WRITE_PORT_USHORT function
		WRITE_REGISTER_BUFFER_UCHAR function
		WRITE_REGISTER_BUFFER_ULONG function
		WRITE_REGISTER_BUFFER_ULONG64 function
		WRITE_REGISTER_BUFFER_USHORT function
		WRITE_REGISTER_UCHAR function
		WRITE_REGISTER_ULONG function
		WRITE_REGISTER_ULONG64 function
		WRITE_REGISTER_USHORT function
		WriteInt32NoFence function
		WriteInt32Raw function
		WriteInt32Release function
		WriteUInt32NoFence function
		WriteUInt32Raw function
		WriteUInt32Release function
		XSAVE_CET_U_FORMAT structure
		ZwClose function
		ZwCommitComplete function
		ZwCommitEnlistment function
		ZwCommitTransaction function
		ZwCreateDirectoryObject function
		ZwCreateEnlistment function
		ZwCreateFile function
		ZwCreateKey function
		ZwCreateKeyTransacted function
		ZwCreateResourceManager function
		ZwCreateSection function
		ZwCreateTransaction function
		ZwCreateTransactionManager function
		ZwDeleteKey function
		ZwDeleteValueKey function
		ZwEnumerateKey function
		ZwEnumerateTransactionObject function
		ZwEnumerateValueKey function
		ZwFlushKey function
		ZwGetNotificationResourceManager function
		ZwLoadDriver function
		ZwMakeTemporaryObject function
		ZwMapViewOfSection function
		ZwOpenEnlistment function
		ZwOpenEvent function
		ZwOpenFile function
		ZwOpenKey function
		ZwOpenKeyEx function
		ZwOpenKeyTransacted function
		ZwOpenKeyTransactedEx function
		ZwOpenResourceManager function
		ZwOpenSection function
		ZwOpenSymbolicLinkObject function
		ZwOpenTransaction function
		ZwOpenTransactionManager function
		ZwPrepareComplete function
		ZwPrepareEnlistment function
		ZwPrePrepareComplete function
		ZwPrePrepareEnlistment function
		ZwQueryFullAttributesFile function
		ZwQueryInformationByName function
		ZwQueryInformationEnlistment function
		ZwQueryInformationFile function
		ZwQueryInformationResourceManager function
		ZwQueryInformationTransaction function
		ZwQueryInformationTransactionManager function
		ZwQueryKey function
		ZwQuerySymbolicLinkObject function
		ZwQueryValueKey function
		ZwReadFile function
		ZwReadOnlyEnlistment function
		ZwRecoverEnlistment function
		ZwRecoverResourceManager function
		ZwRecoverTransactionManager function
		ZwRollbackComplete function
		ZwRollbackEnlistment function
		ZwRollbackTransaction function
		ZwRollforwardTransactionManager function
		ZwSetInformationEnlistment function
		ZwSetInformationFile function
		ZwSetInformationResourceManager function
		ZwSetInformationTransaction function
		ZwSetValueKey function
		ZwSinglePhaseReject function
		ZwUnloadDriver function
		ZwUnmapViewOfSection function
		ZwWriteFile function
		*/
	}
}
